C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/Utilities/NativeAudio.cs

#region File Description
//-----------------------------------------------------------------------------
// NativeAudio.cs
//-----------------------------------------------------------------------------
#endregion

namespace NewGamePhysics.Utilities
{
    using System;
    using System.Threading;
    using System.Runtime.InteropServices;

    [StructLayout(LayoutKind.Sequential)] 
    public class WaveFormat
    {
        public ushort formatTag;

        public ushort channels;

        public uint samplesPerSec;

        public uint averageBytesPerSec;

        public ushort blockAlignment;

        public ushort bitsPerSample;

        public short cbSize;

        public WaveFormat(uint rate, ushort bits, ushort channels)
        {
            if (!(rate > 0))
            {
                throw new ArgumentException("'rate' must be greater than >0", "rate");
            }

            if (!((bits == 8) || (bits == 16)))
            {
                throw new ArgumentException("'bits' must be 8 or 16", "bits");
            }

            if (!((channels == 1) || (channels == 2)))
            {
                throw new ArgumentException("'channels' must be 1 or 2", "channels");
            }

            this.formatTag = 1; // lock to PCM
            this.channels = channels;
            this.samplesPerSec = rate;
            this.bitsPerSample = bits;
            this.cbSize = 0;
               
            this.blockAlignment = (ushort)(channels * (bits / 8));
            this.averageBytesPerSec = samplesPerSec * blockAlignment;
        }
    }

    public class NativeAudioInterface
    {
        private const int MMSYSERR_BASE = 0;

        private enum MMSYSERR : int
        {
            NOERROR = 0,
            ERROR = (MMSYSERR_BASE + 1),
            BADDEVICEID = (MMSYSERR_BASE + 2),
            NOTENABLED = (MMSYSERR_BASE + 3),
            ALLOCATED = (MMSYSERR_BASE + 4),
            INVALHANDLE = (MMSYSERR_BASE + 5),
            NODRIVER = (MMSYSERR_BASE + 6),
            NOMEM = (MMSYSERR_BASE + 7),
            NOTSUPPORTED = (MMSYSERR_BASE + 8),
            BADERRNUM = (MMSYSERR_BASE + 9),
            INVALFLAG = (MMSYSERR_BASE + 10),
            INVALPARAM = (MMSYSERR_BASE + 11),
            HANDLEBUSY = (MMSYSERR_BASE + 12),
            INVALIDALIAS = (MMSYSERR_BASE + 13),
            BADDB = (MMSYSERR_BASE + 14),
            KEYNOTFOUND = (MMSYSERR_BASE + 15),
            READERROR = (MMSYSERR_BASE + 16),
            WRITEERROR = (MMSYSERR_BASE + 17),
            DELETEERROR = (MMSYSERR_BASE + 18),
            VALNOTFOUND = (MMSYSERR_BASE + 19),
            NODRIVERCB = (MMSYSERR_BASE + 20),
            LASTERROR = (MMSYSERR_BASE + 20)
        }

        private const int WAVERR_BASE = 32;

        private enum WAVERR : int
        {
            NONE = 0,
            BADFORMAT = WAVERR_BASE + 0,
            STILLPLAYING = WAVERR_BASE + 1,
            UNPREPARED = WAVERR_BASE + 2,
            SYNC = WAVERR_BASE + 3,
            LASTERROR = WAVERR_BASE + 3
        }

        public const int MMSYSERR_NOERROR = 0;

        public const int MM_WOM_OPEN = 0x3BB;

        public const int MM_WOM_CLOSE = 0x3BC;

        public const int MM_WOM_DONE = 0x3BD;

        public const int CALLBACK_FUNCTION = 0x00030000;

        public delegate void WaveDelegate(
            IntPtr hdrvr, 
            int uMsg, 
            int dwUser, 
            ref WaveHeader wavhdr, 
            int dwParam2);

        [StructLayout(LayoutKind.Sequential)] public struct WaveHeader
        {
            public IntPtr lpData;

            public int dwBufferLength;

            public int dwBytesRecorded;

            public IntPtr dwUser;

            public int dwFlags;

            public int dwLoops;

            public IntPtr lpNext;

            public int reserved;
        }

        #region native_calls
        private const string mmdll = "winmm.dll";

        [DllImport(mmdll)]
        public static extern int waveOutPrepareHeader(IntPtr hWaveOut, ref WaveHeader lpWaveOutHdr, int uSize);
        
        [DllImport(mmdll)]
        public static extern int waveOutUnprepareHeader(IntPtr hWaveOut, ref WaveHeader lpWaveOutHdr, int uSize);
        
        [DllImport(mmdll)]
        public static extern int waveOutWrite(IntPtr hWaveOut, ref WaveHeader lpWaveOutHdr, int uSize);
        
        [DllImport(mmdll)]
        public static extern int waveOutOpen(out IntPtr hWaveOut, int uDeviceID, WaveFormat lpFormat, WaveDelegate dwCallback, int dwInstance, int dwFlags);
        
        [DllImport(mmdll)]
        public static extern int waveOutReset(IntPtr hWaveOut);
        
        [DllImport(mmdll)]
        public static extern int waveOutClose(IntPtr hWaveOut);

        #endregion
    }

    public delegate void BufferFillCallback(byte[] data);

        internal class SampleBuffer : IDisposable
        {
        private const int BufferWaitTimeoutSeconds = 10;

        private IntPtr waveData;

        private AutoResetEvent bufferCompleted = new AutoResetEvent(false);

        private NativeAudioInterface.WaveHeader header;

        private GCHandle headerHandle;

        private byte[] headerData;

        private GCHandle headerDataHandle;

        private bool isPlaying;

        internal static void WaveOutProc(
            IntPtr hdrvr, 
            int message, 
            int dwUser, 
            ref NativeAudioInterface.WaveHeader waveHeader, 
            int dwParam2)
        {
            if (message == NativeAudioInterface.MM_WOM_DONE)
            {
                try
                {
                    GCHandle h = (GCHandle)waveHeader.dwUser;
                    SampleBuffer buffer = (SampleBuffer)h.Target;
                    buffer.OnCompleted();
                }
                catch
                {
                }
            }
        }

        public SampleBuffer(IntPtr waveOutHandle, int bufferSize)
                {
            // Sample buffer
            waveData = waveOutHandle;

            // Create header
            headerHandle = GCHandle.Alloc(header, GCHandleType.Pinned);
            header.dwUser = (IntPtr)GCHandle.Alloc(this);

            // Create sample buffer
            headerData = new byte[bufferSize];
            headerDataHandle = GCHandle.Alloc(headerData, GCHandleType.Pinned);
            header.lpData = headerDataHandle.AddrOfPinnedObject();
            header.dwBufferLength = bufferSize;

            // Prepare sample buffer
            int error = NativeAudioInterface.waveOutPrepareHeader(
                waveData, 
                ref header, 
                Marshal.SizeOf(header));
            if (error != NativeAudioInterface.MMSYSERR_NOERROR)
            {
                throw new ApplicationException("Could not prepare sample buffer.");
            }
                }

        ~SampleBuffer()
        {
            Dispose();
        }

        public void Dispose()
        {
            // Clean header
            if (header.lpData != IntPtr.Zero)
            {
                NativeAudioInterface.waveOutUnprepareHeader(waveData, ref header, Marshal.SizeOf(header));
                headerHandle.Free();
                header.lpData = IntPtr.Zero;
            }
            
            // Clean sample buffer
            if (headerDataHandle.IsAllocated)
            {
                headerDataHandle.Free();
            }

            // Clean event
            bufferCompleted.Close();

            GC.SuppressFinalize(this);
        }

        public int Size
        {
            get { return header.dwBufferLength; }
        }

        public IntPtr Data
        {
            get { return header.lpData; }
        }

        public bool Play()
        {
            lock(this)
            {
                this.bufferCompleted.Reset();
                int result = NativeAudioInterface.waveOutWrite(
                    waveData, 
                    ref header, 
                    Marshal.SizeOf(header));
                this.isPlaying = (result == NativeAudioInterface.MMSYSERR_NOERROR);                
            }

            return this.isPlaying;
        }

        public void WaitForBuffer()
        {
            if (this.isPlaying)
            {
                this.bufferCompleted.WaitOne(new TimeSpan(0, 0, BufferWaitTimeoutSeconds));
            }
        }

        public void OnCompleted()
        {
            lock (this)
            {
                this.bufferCompleted.Set();
                this.isPlaying = false;
            }
        }
    }

    public class WaveOutPlayer : IDisposable
    {
        private const int NumBuffers = 2;

        private const int BufferSize = 4096;

        private IntPtr waveOutHandle;

        private SampleBuffer[] buffers = new SampleBuffer[NumBuffers];

        private int currentBuffer;

        private Thread fillBufferThread;

        private BufferFillCallback bufferFillCallback;

                private bool finished;

                private byte zeroSampleValue;

        private NativeAudioInterface.WaveDelegate waveOutProc = 
            new NativeAudioInterface.WaveDelegate(SampleBuffer.WaveOutProc);

        public WaveOutPlayer( 
            WaveFormat format, 
            BufferFillCallback bufferFillCallback)
        {
            // Determine quiet sample value
                        this.zeroSampleValue = format.bitsPerSample == 8 ? (byte)128 : (byte)0;

            // Remember callback
            this.bufferFillCallback = bufferFillCallback;

            // Open wave out device.
            int result = NativeAudioInterface.waveOutOpen(
                out waveOutHandle, 
                -1, 
                format, 
                waveOutProc,
                0, 
                NativeAudioInterface.CALLBACK_FUNCTION);
            if (result != NativeAudioInterface.MMSYSERR_NOERROR)
            {
                throw new ApplicationException("Could not open wave out device. Error: " + result);
            }

            // Allocate sample buffers.
            AllocateBuffers();

            // Start thread which provides sample data.
            fillBufferThread = new Thread(new ThreadStart(WaveOutPlayerThread));
            fillBufferThread.Start();
        }

        ~WaveOutPlayer()
        {
            Dispose();
        }

        public void Dispose()
        {
            if (fillBufferThread != null)
            {
                try
                {
                    finished = true;
                    if (waveOutHandle != IntPtr.Zero)
                    {
                        NativeAudioInterface.waveOutReset(waveOutHandle);
                    }

                    fillBufferThread.Join();
                    bufferFillCallback = null;
                    FreeBuffers();
                    if (waveOutHandle != IntPtr.Zero)
                    {
                        NativeAudioInterface.waveOutClose(waveOutHandle);
                    }
                }
                finally
                {
                    fillBufferThread = null;
                    waveOutHandle = IntPtr.Zero;
                }
            }

            GC.SuppressFinalize(this);
        }

        private void WaveOutPlayerThread()
        {
            while (!finished)
            {
                byte[] sampleData = new byte[BufferSize];
                
                if (bufferFillCallback != null)
                {
                    // Fill samples via callback
                    bufferFillCallback(sampleData);
                }
                else
                {
                    // Create a buffer with zero sample values
                    for (int i = 0; i < BufferSize; i++)
                    {
                        sampleData[i] = zeroSampleValue;
                    }
                }

                // Wait for buffer to complete playing
                this.buffers[currentBuffer].WaitForBuffer();

                // Copy new sample data to unmanaged side
                System.Runtime.InteropServices.Marshal.Copy(
                    sampleData, 0, buffers[currentBuffer].Data, buffers[currentBuffer].Size);

                // Trigger playback of buffer via wavOut device
                this.buffers[currentBuffer].Play();

                // Advance to next buffer to fill
                currentBuffer++;
                currentBuffer = currentBuffer % NumBuffers;                 
            }

            // Wait for all buffers to finish playing
                        WaitForAllBuffers();
                }

        private void AllocateBuffers()
        {
            FreeBuffers();
            for (int i = 0; i < NumBuffers; i++)
            {
                this.buffers[i] = new SampleBuffer(this.waveOutHandle, BufferSize);
            }
        }

        private void FreeBuffers()
        {
            for (int i = 0; i < NumBuffers; i++)
            {
                if (this.buffers[i] != null)
                {
                    this.buffers[i].Dispose();
                    this.buffers[i] = null;
                }
            }
        }

        private void WaitForAllBuffers()
        {
            for (int i = 0; i < NumBuffers; i++)
            {
                if (this.buffers[i] != null)
                {
                    this.buffers[i].WaitForBuffer();
                }
            }
        }
    }
}

---