public static WaveOutCaps GetDevice(int device)
{
WaveOutCaps caps = new WaveOutCaps();
MMInterops.waveOutGetDevCaps((uint)device, out caps, (uint)Marshal.SizeOf(caps));
return(caps);
}
protected virtual void OpenWaveDevice(int device)
{
_callback = new MMInterops.WaveCallback(Callback);
var result = MMInterops.waveInOpen(out handle, (IntPtr)device, _waveFormat, _callback, IntPtr.Zero, MMInterops.WaveInOutOpenFlags.CALLBACK_FUNCTION);
MmException.Try(result, "waveInOpen");
}
public void Resume()
{
if (_playbackState == SoundOut.PlaybackState.Paused)
{
lock (_lockObj)
{
Debug.WriteLine(MMInterops.waveOutRestart(_hWaveOut),
"waveOutRestart");
}
_playbackState = SoundOut.PlaybackState.Playing;
}
}
public void Pause()
{
if (_playbackState == SoundOut.PlaybackState.Playing)
{
lock (_lockObj)
{
Debug.WriteLine(MMInterops.waveOutPause(_hWaveOut),
"waveOutPause");
}
_playbackState = SoundOut.PlaybackState.Paused;
}
}
protected override IntPtr CreateWaveOut()
{
IntPtr ptr;
lock (_lockObj)
{
MmException.Try(MMInterops.waveOutOpenWithWindow(out ptr, (IntPtr)Device, WaveSource.WaveFormat, WindowHandle,
IntPtr.Zero, MMInterops.WaveInOutOpenFlags.CALLBACK_WINDOW),
"waveOutOpenWithWindow <-- waveOutOpen");
}
return(ptr);
}
protected virtual IntPtr CreateWaveOut()
{
IntPtr handle;
MmException.Try(MMInterops.waveOutOpen(out handle,
(IntPtr)_device,
_source.WaveFormat,
callback,
IntPtr.Zero,
MMInterops.WaveInOutOpenFlags.CALLBACK_FUNCTION), "waveOutOpen");
return(handle);
}
public static WaveInCaps[] GetCaps()
{
uint count = (uint)MMInterops.waveInGetNumDevs();
WaveInCaps[] caps = new WaveInCaps[count];
for (uint i = 0; i < count; i++)
{
WaveInCaps c;
var result = MMInterops.waveInGetDevCaps(i, out c, (uint)Marshal.SizeOf(typeof(WaveInCaps)));
MmException.Try(result, "waveInGetDevCaps");
caps[i] = c;
}
return(caps);
}
public void Stop()
{
if (_playbackState != SoundOut.PlaybackState.Stopped)
{
_playbackState = SoundOut.PlaybackState.Stopped;
lock (_lockObj)
{
var result = MMInterops.waveOutReset(_hWaveOut);
Debug.WriteLine(
result,
"waveOutReset"
);
MmException.Try(result, "waveOutReset");
}
RaiseStopped();
}
}
public void Start()
{
if (!stopped)
{
throw new InvalidOperationException("Recording has to be stopped");
}
if (Handle == IntPtr.Zero)
{
throw new InvalidOperationException("Not initialized");
}
ResetBuffers();
var result = MMInterops.waveInStart(Handle);
MmException.Try(result, "waveInStart");
stopped = false;
OnStarted();
}
public void Stop()
{
if (!stopped)
{
stopped = true;
var result = MMInterops.waveInStop(Handle);
MmException.Try(result, "waveInStop");
OnStopping();
foreach (var buffer in _buffers)
{
if (buffer.Done)
{
RaiseDataAvailable(buffer);
}
}
//RaiseStopped();
OnStopped();
}
}
private void CloseWaveDevice()
{
if (Handle == IntPtr.Zero)
{
return;
}
var result = MMInterops.waveInReset(Handle);
MmException.Try(result, "waveInReset");
if (_buffers != null)
{
for (int i = 0; i < _buffers.Length; i++)
{
_buffers[i].Dispose();
}
}
result = MMInterops.waveInClose(Handle);
MmException.Try(result, "waveInClose");
handle = IntPtr.Zero;
}
public virtual void Dispose(bool disposing)
{
if (_hWaveOut == IntPtr.Zero)
{
return;
}
Stop();
lock (_lockObj)
{
if (_buffers != null)
{
foreach (var buffer in _buffers)
{
buffer.Dispose();
}
}
MmException.Try(MMInterops.waveOutClose(_hWaveOut), "waveOutClose");
_hWaveOut = IntPtr.Zero;
}
Debug.WriteLine("WaveOut disposed.");
}
protected override void OpenWaveDevice(int device)
{
var result = MMInterops.waveInOpenWithWindow(out handle, (IntPtr)Device, WaveFormat, WindowHandle, IntPtr.Zero, MMInterops.WaveInOutOpenFlags.CALLBACK_WINDOW);
MmException.Try(result, "waveInOpen");
}
protected override void OpenWaveDevice(int device)
{
var result = MMInterops.waveInOpenWithWindow(out handle, (IntPtr)device, WaveFormat, _event.SafeWaitHandle.DangerousGetHandle(), IntPtr.Zero, MMInterops.WaveInOutOpenFlags.CALLBACK_EVENT);
MmException.Try(result, "waveInOpen");
}
private void AddBuffer()
{
var result = MMInterops.waveInAddBuffer(_waveInHandle, _header, Marshal.SizeOf(_header));
MmException.Try(result, "waveInAddBuffer");
}
private void Prepare()
{
var result = MMInterops.waveInPrepareHeader(_waveInHandle, _header, Marshal.SizeOf(_header));
MmException.Try(result, "waveInPrepareHeader");
}
public static int GetDeviceCount()
{
return(MMInterops.waveOutGetNumDevs());
}
