Alsa

Directory.Build.props

@@ -0,0 +1,3 @@
+<Project>
+    <!-- Only here so that the default Directory.Build.props will not be used. -->
+</Project>

NAudio.Alsa/AlsaCard.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using NAudio.Wave;
+namespace NAudio.Wave.Alsa
+{
+    public class AlsaCard : IDisposable
+    {
+        public string IdString { get; private set; }
+        public int Index { get; private set; }
+        public string Id { get; private set; }
+        public string Driver { get; private set; }
+        public string Name { get; private set; }
+        public string LongName { get; private set; }
+        public string MixerName { get; private set; }
+        public string Components { get; private set; }
+        private IntPtr handle;
+        public IntPtr Handle 
+        {
+            get => handle;
+        }
+        public List<AlsaOut> OutputDevices { get; private set; } = new List<AlsaOut>();    
+        public string[] GetDeviceNames()
+        {
+            return new string[] { "" };
+        }
+        private AlsaCard(IntPtr handle) 
+        {
+            this.handle = handle;
+        }
+        public static unsafe bool Create(string name, out AlsaCard card)
+        {
+            int error;
+            card = null;
+            IntPtr info = default;
+            AlsaInterop.CtlCardInfoMalloc(ref info);
+            if ((error = AlsaInterop.CtlOpen(out IntPtr handle, name, 0)) < 0)
+            {
+                AlsaInterop.CtlCardInfoFree(info);
+                Console.WriteLine(AlsaInterop.ErrorString(error));
+                return false;
+            }
+            if ((error = AlsaInterop.CtlCardInfo(handle, info)) < 0)
+            {
+                AlsaInterop.CtlCardInfoFree(info);
+                Console.WriteLine(AlsaInterop.ErrorString(error));
+                AlsaInterop.CtlClose(handle);
+                return false;
+            }
+            card = new AlsaCard(handle);
+            card.IdString = name;
+            int dev = -1;
+            do 
+            {
+                if ((error = AlsaInterop.CtlPcmNextDevice(handle, ref dev)) < 0)
+                {
+                    AlsaInterop.CtlCardInfoFree(info);
+                    Console.WriteLine(AlsaInterop.ErrorString(error));
+                    return false;
+                }
+                if (dev < 0)
+                {
+                    break;
+                }
+                if (AlsaOut.Create(card, dev, out AlsaOut device))
+                {
+                    card.OutputDevices.Add(device);
+                }
+            } while (true);
+            card.Name = AlsaInterop.CtlCardInfoGetName(info);
+            card.Index = AlsaInterop.CtlCardInfoGetCard(info);
+            card.Id = AlsaInterop.CtlCardInfoGetID(info);
+            card.Driver = AlsaInterop.CtlCardInfoGetDriver(info);
+            card.LongName = AlsaInterop.CtlCardInfoGetLongName(info);
+            card.MixerName = AlsaInterop.CtlCardInfoGetMixerName(info); 
+            card.Components = AlsaInterop.CtlCardInfoGetComponents(info); 
+            AlsaInterop.CtlCardInfoFree(info);
+            return true;
+        }
+        public void Dispose()
+        {
+            AlsaInterop.CtlClose(handle);
+        }
+        public override string ToString()
+        {
+            return $"card {Index}: {Id} [{Name}]";
+        }
+        ~AlsaCard()
+        {
+            Console.WriteLine("Disposing ALSA Card");
+            Dispose();
+        }
+    }
+}

NAudio.Alsa/AlsaDriver.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+namespace NAudio.Wave.Alsa
+{
+    public class AlsaDriver
+    {
+        private IntPtr _playbackPcm;
+        private List<AlsaCard> _cards = new List<AlsaCard>();
+        public AlsaDriver()
+        {
+            EnumerateCards();
+        }
+        public void EnumerateCards()
+        {
+            int card = -1;
+            if (AlsaInterop.NextCard(ref card) < 0 || card < 0)
+            {
+                throw new Exception("no soundcards found");
+            }
+            while (card >= 0){
+                string name = $"hw:{card.ToString()}";
+                if (AlsaCard.Create(name, out AlsaCard card_obj))
+                {
+                    _cards.Add(card_obj);
+                    Console.WriteLine(name);
+                }
+                AlsaInterop.NextCard(ref card);
+            }
+        }
+        internal static PCMFormat GetFormat(WaveFormat format)
+        {
+            switch (format.Encoding)
+            {
+                case WaveFormatEncoding.IeeeFloat:
+                    switch (format.BitsPerSample)
+                    {
+                        case 32:
+                            return PCMFormat.SND_PCM_FORMAT_FLOAT_LE;
+                    }
+                    break;
+                case WaveFormatEncoding.Pcm:
+                    switch (format.BitsPerSample)
+                    {
+                        case 32:
+                            return PCMFormat.SND_PCM_FORMAT_S32_LE;
+                        case 24:
+                            return PCMFormat.SND_PCM_FORMAT_S24_3LE;
+                        case 16:
+                            return PCMFormat.SND_PCM_FORMAT_S16_LE;
+                        case 8:
+                            return PCMFormat.SND_PCM_FORMAT_S8;
+                    }
+                    break;
+                case WaveFormatEncoding.MuLaw:
+                    return PCMFormat.SND_PCM_FORMAT_MU_LAW;
+                case WaveFormatEncoding.ALaw:
+                    return PCMFormat.SND_PCM_FORMAT_A_LAW;
+            }
+            return PCMFormat.SND_PCM_FORMAT_UNKNOWN;
+        }
+    }
+}

NAudio.Alsa/AlsaException.cs

@@ -0,0 +1,13 @@
+using System;
+using NAudio.Wave.Alsa;
+
+[Serializable]
+public class AlsaException : Exception
+{
+    public AlsaException(int error) : base(AlsaInterop.ErrorString(error))
+    {
+    }
+    public AlsaException(string message, int error) : base(string.Format("{0}: {1}", message, AlsaInterop.ErrorString(error)))
+    {
+    }
+}

NAudio.Alsa/AlsaIn.cs

@@ -0,0 +1,176 @@
+using System;
+using NAudio.Wave.Alsa;
+using System.Threading.Tasks;
+using System.Linq;
+
+namespace NAudio.Wave
+{
+    public class AlsaIn : AlsaPcm, IWaveIn
+    {
+        private bool recording;
+        private AlsaInterop.PcmCallback callback;
+        public void StartRecording()
+        {
+            if (recording)
+            {
+                throw new InvalidOperationException("Already recording");
+            }
+            InitRecord(WaveFormat);
+            int error;
+            recording = true;
+            if ((error = AlsaInterop.PcmStart(Handle)) < 0)
+            {
+                throw new AlsaException("snd_pcm_start", error);
+            }
+            else if (!Async)
+            {
+                RecordPcmSync();
+            }
+        }    
+        public void StopRecording()
+        {
+            recording = false;
+            int error;
+            if ((error = AlsaInterop.PcmDrop(Handle)) < 0)
+            {
+                RaiseRecordingStopped(new AlsaException(error));
+            }
+            else
+            {
+                RaiseRecordingStopped(null);
+            }
+        }
+        public WaveFormat WaveFormat { get; set;}
+        public event EventHandler<WaveInEventArgs> DataAvailable;
+        public event EventHandler<StoppedEventArgs> RecordingStopped;
+        public void Dispose()
+        {
+            if (isDisposed)
+            {
+                return;
+            }
+            isDisposed = true;
+            AlsaInterop.PcmHwParamsFree(HwParams);
+            AlsaInterop.PcmSwParamsFree(SwParams);
+            AlsaInterop.PcmClose(Handle);
+        }
+        public AlsaIn(string pcm_name)
+        {
+            int error;
+            if ((error = AlsaInterop.PcmOpen(out Handle, pcm_name, PCMStream.SND_PCM_STREAM_CAPTURE, 0)) < 0)
+            {
+                throw new AlsaException("snd_pcm_open", error);
+            }
+            callback = Callback;
+            ulong buffer_size = PERIOD_SIZE * PERIOD_QUANTITY;
+            if ((error = AlsaInterop.AsyncAddPcmHandler(out IntPtr handler, Handle, callback, default)) != 0)
+            {
+                Async = false;
+            }
+            else
+            {
+                Async = true;
+            }
+        }
+        private void InitRecord(WaveFormat waveFormat)
+        {
+            GetHardwareParams();
+            int error;
+            int dir = 0;
+            uint periods = PERIOD_QUANTITY;
+            if (isInitialized)
+            {
+                throw new InvalidOperationException("Already initialized");
+            }
+            isInitialized = true;
+            InitBuffers();
+            ulong buffer_size = (ulong)WaveBuffer.Length;
+            SetInterleavedAccess();
+            SetFormat(waveFormat);
+            SetPeriods(ref periods, ref dir);
+            SetBufferSize(ref buffer_size);
+            SetHardwareParams();
+            GetSoftwareParams();
+            if ((error = AlsaInterop.PcmSwParamsSetStartThreshold(Handle, SwParams, buffer_size - PERIOD_SIZE)) < 0)
+            {
+                throw new AlsaException(error);
+            }
+            if ((error = AlsaInterop.PcmSwParamsSetAvailMin(Handle, SwParams, PERIOD_SIZE)) < 0)
+            {
+                throw new AlsaException(error);
+            }
+            SetSoftwareParams();
+            AlsaInterop.PcmPrepare(Handle);
+        }
+        public AlsaIn() : this("default")
+        {
+        }
+        ~AlsaIn()
+        {
+            Dispose();
+        }
+        private void Callback(IntPtr cb_info)
+        {
+            ReadPcm();
+        }
+        private void ReadPcm()
+        {
+            ulong avail = AlsaInterop.PcmAvailUpdate(Handle);
+            int bits_per_frame = WaveFormat.BitsPerSample * WaveFormat.Channels;
+            int frame_bytes = bits_per_frame / 8;
+            while (avail >= PERIOD_SIZE)
+            {
+                int frames = AlsaInterop.PcmReadI(Handle, WaveBuffer, PERIOD_SIZE);
+                if (frames < 0)
+                {
+                    recording = false;
+                    RaiseRecordingStopped(new AlsaException(frames));
+                }
+                if (!Async) SwapBuffers();
+                RaiseDataAvailable(WaveBuffer, frames * frame_bytes);
+                avail = AlsaInterop.PcmAvailUpdate(Handle);
+            }
+        }
+        private void RecordPcmSync()
+        {
+            Task.Run(() => {
+                while (recording)
+                {
+                    ReadPcm();
+                }
+            });
+        }
+        private void SetFormat(WaveFormat format)
+        {
+            int error;
+            if (GetValidWaveFormats().Contains(format))
+            {
+                WaveFormat = format;
+            }
+            else 
+            {
+                throw new NotSupportedException($"{format} not supported");
+            }
+            var sampleformat = AlsaDriver.GetFormat(WaveFormat);
+            if ((error = AlsaInterop.PcmHwParamsSetFormat(Handle, HwParams, sampleformat)) < 0)
+            {
+                throw new AlsaException(error);
+            }
+            int desiredSampleRate = WaveFormat.SampleRate;
+            SetSampleRate((uint)desiredSampleRate);
+            SetNumberOfChannels((uint)WaveFormat.Channels);
+        }
+        private void RaiseRecordingStopped(Exception e)
+        {
+            var handler = RecordingStopped;
+            if (handler != null)
+            {
+                handler(this, new StoppedEventArgs(e));
+            }
+        }
+        private void RaiseDataAvailable(byte[] buffer, int bytes)
+        {
+            DataAvailable?.Invoke(this, new WaveInEventArgs(buffer, bytes));
+        }
+    }
+}