using System;
using System.Runtime.InteropServices;
using System.Threading;
using NAudio.Mixer;
// ReSharper disable once CheckNamespace
namespace NAudio.Wave
{
///
/// Allows recording using the Windows waveIn APIs
/// Events are raised as recorded buffers are made available
///
public class WaveIn : IWaveIn
{
private IntPtr waveInHandle;
private volatile bool recording;
private WaveInBuffer[] buffers;
private readonly WaveInterop.WaveCallback callback;
private WaveCallbackInfo callbackInfo;
private readonly SynchronizationContext syncContext;
private int lastReturnedBufferIndex;
///
/// Indicates recorded data is available
///
public event EventHandler DataAvailable;
///
/// Indicates that all recorded data has now been received.
///
public event EventHandler RecordingStopped;
///
/// Prepares a Wave input device for recording
///
public WaveIn()
: this(WaveCallbackInfo.NewWindow())
{
}
///
/// Creates a WaveIn device using the specified window handle for callbacks
///
/// A valid window handle
public WaveIn(IntPtr windowHandle)
: this(WaveCallbackInfo.ExistingWindow(windowHandle))
{
}
///
/// Prepares a Wave input device for recording
///
public WaveIn(WaveCallbackInfo callbackInfo)
{
syncContext = SynchronizationContext.Current;
if ((callbackInfo.Strategy == WaveCallbackStrategy.NewWindow || callbackInfo.Strategy == WaveCallbackStrategy.ExistingWindow) &&
syncContext == null)
{
throw new InvalidOperationException("Use WaveInEvent to record on a background thread");
}
DeviceNumber = 0;
WaveFormat = new WaveFormat(8000, 16, 1);
BufferMilliseconds = 100;
NumberOfBuffers = 3;
callback = Callback;
this.callbackInfo = callbackInfo;
callbackInfo.Connect(callback);
}
///
/// Returns the number of Wave In devices available in the system
///
public static int DeviceCount
{
get
{
return WaveInterop.waveInGetNumDevs();
}
}
///
/// Retrieves the capabilities of a waveIn device
///
/// Device to test
/// The WaveIn device capabilities
public static WaveInCapabilities GetCapabilities(int devNumber)
{
var caps = new WaveInCapabilities();
int structSize = Marshal.SizeOf(caps);
MmException.Try(WaveInterop.waveInGetDevCaps((IntPtr)devNumber, out caps, structSize), "waveInGetDevCaps");
return caps;
}
///
/// Milliseconds for the buffer. Recommended value is 100ms
///
public int BufferMilliseconds { get; set; }
///
/// Number of Buffers to use (usually 2 or 3)
///
public int NumberOfBuffers { get; set; }
///
/// The device number to use
///
public int DeviceNumber { get; set; }
private void CreateBuffers()
{
// Default to three buffers of 100ms each
int bufferSize = BufferMilliseconds * WaveFormat.AverageBytesPerSecond / 1000;
if (bufferSize % WaveFormat.BlockAlign != 0)
{
bufferSize -= bufferSize % WaveFormat.BlockAlign;
}
buffers = new WaveInBuffer[NumberOfBuffers];
for (int n = 0; n < buffers.Length; n++)
{
buffers[n] = new WaveInBuffer(waveInHandle, bufferSize);
}
}
///
/// Called when we get a new buffer of recorded data
///
private void Callback(IntPtr waveInHandle, WaveInterop.WaveMessage message, IntPtr userData, WaveHeader waveHeader, IntPtr reserved)
{
if (message == WaveInterop.WaveMessage.WaveInData)
{
if (recording)
{
var hBuffer = (GCHandle)waveHeader.userData;
var buffer = (WaveInBuffer)hBuffer.Target;
if (buffer == null) return;
lastReturnedBufferIndex = Array.IndexOf(buffers, buffer);
RaiseDataAvailable(buffer);
try
{
buffer.Reuse();
}
catch (Exception e)
{
recording = false;
RaiseRecordingStopped(e);
}
}
}
}
private void RaiseDataAvailable(WaveInBuffer buffer)
{
DataAvailable?.Invoke(this, new WaveInEventArgs(buffer.Data, buffer.BytesRecorded));
}
private void RaiseRecordingStopped(Exception e)
{
var handler = RecordingStopped;
if (handler != null)
{
if (syncContext == null)
{
handler(this, new StoppedEventArgs(e));
}
else
{
syncContext.Post(state => handler(this, new StoppedEventArgs(e)), null);
}
}
}
private void OpenWaveInDevice()
{
CloseWaveInDevice();
MmResult result = callbackInfo.WaveInOpen(out waveInHandle, DeviceNumber, WaveFormat, callback);
MmException.Try(result, "waveInOpen");
CreateBuffers();
}
///
/// Start recording
///
public void StartRecording()
{
if (recording)
{
throw new InvalidOperationException("Already recording");
}
OpenWaveInDevice();
EnqueueBuffers();
MmException.Try(WaveInterop.waveInStart(waveInHandle), "waveInStart");
recording = true;
}
private void EnqueueBuffers()
{
foreach (var buffer in buffers)
{
if (!buffer.InQueue)
{
buffer.Reuse();
}
}
}
///
/// Stop recording
///
public void StopRecording()
{
if (recording)
{
recording = false;
MmException.Try(WaveInterop.waveInStop(waveInHandle), "waveInStop");
// report the last buffers, sometimes more than one, so taking care to report them in the right order
for (int n = 0; n < buffers.Length; n++)
{
int index = (n + lastReturnedBufferIndex + 1)%buffers.Length;
var buffer = buffers[index];
if (buffer.Done)
{
RaiseDataAvailable(buffer);
}
}
RaiseRecordingStopped(null);
}
//MmException.Try(WaveInterop.waveInReset(waveInHandle), "waveInReset");
// Don't actually close yet so we get the last buffer
}
///
/// WaveFormat we are recording in
///
public WaveFormat WaveFormat { get; set; }
///
/// Dispose pattern
///
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (recording)
StopRecording();
CloseWaveInDevice();
if (callbackInfo != null)
{
callbackInfo.Disconnect();
callbackInfo = null;
}
}
}
private void CloseWaveInDevice()
{
if (waveInHandle == IntPtr.Zero) return;
// Some drivers need the reset to properly release buffers
WaveInterop.waveInReset(waveInHandle);
if (buffers != null)
{
for (int n = 0; n < buffers.Length; n++)
{
buffers[n].Dispose();
}
buffers = null;
}
WaveInterop.waveInClose(waveInHandle);
waveInHandle = IntPtr.Zero;
}
///
/// Microphone Level
///
public MixerLine GetMixerLine()
{
// TODO use mixerGetID instead to see if this helps with XP
MixerLine mixerLine;
if (waveInHandle != IntPtr.Zero)
{
mixerLine = new MixerLine(waveInHandle, 0, MixerFlags.WaveInHandle);
}
else
{
mixerLine = new MixerLine((IntPtr)DeviceNumber, 0, MixerFlags.WaveIn);
}
return mixerLine;
}
///
/// Dispose method
///
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
}