unsafe void AllocateHeaders()
{
if (this._hwih == IntPtr.Zero)
{
throw new InvalidOperationException();
}
for (int i = 0; i < _headers.Length; i++)
{
if (_headers[i] == IntPtr.Zero)
{
WaveHeader *pwh = (WaveHeader *)Marshal.AllocHGlobal(Marshal.SizeOf(typeof(WaveHeader)));
(*pwh).dwFlags = 0;
(*pwh).dwBufferLength = _cc
* _wfx.nBlockAlign;
(*pwh).lpData = Marshal.AllocHGlobal((*pwh).dwBufferLength);
(*pwh).dwUser = IntPtr.Zero;
_headers[i] = (IntPtr)pwh;
WinMM.Throw(
WinMM.waveInPrepareHeader(this._hwih, _headers[i], Marshal.SizeOf(typeof(WaveHeader))),
WinMM.ErrorSource.WaveOut);
WinMM.Throw(
WinMM.waveInAddBuffer(this._hwih, _headers[i], Marshal.SizeOf(typeof(WaveHeader))),
WinMM.ErrorSource.WaveOut);
}
}
}
Mic32 OpenMic()
{
var hMic32 = new Microsoft.WinMM.Mic32(1024, 44100, (hMic, hWaveHeader) => {
WaveHeader *pwh = (WaveHeader *)hWaveHeader;
if (pwh != null)
{
short *psData =
(short *)((*pwh).lpData);
hMic.CaptureData(pwh, psData);
if (pwh != null)
{
(*pwh).dwFlags = (*pwh).dwFlags & ~WaveHeaderFlags.Done;
}
WinMM.Throw(
WinMM.waveInAddBuffer(hMic.Handle, hWaveHeader, Marshal.SizeOf(typeof(WaveHeader))),
WinMM.ErrorSource.WaveIn);
}
PostWinMMMessage(hMic, hWaveHeader);
});
try {
hMic32.Open(false);
} catch (Exception e) {
Console.Error?.WriteLine(e);
hMic32.Dispose();
return(null);
}
return(hMic32);
}
unsafe void FreeHeaders()
{
for (int i = 0; i < _headers.Length; i++)
{
WaveHeader *pwh = (WaveHeader *)_headers[i];
Marshal.FreeHGlobal((*pwh).lpData);
Marshal.FreeHGlobal((IntPtr)pwh);
_headers[i] = IntPtr.Zero;
}
}
public unsafe void CaptureData(WaveHeader *pwh, short *psData)
{
lock (_dataLock) {
for (int s = 0; s < _cc; s++)
{
float ch1 = (psData[(s * Channels)] / 32767.0f),
ch2 = (psData[(s * Channels) + 1] / 32767.0f);
_CH1[s] = (float)ch1;
_CH2[s] = (float)ch2;
}
}
}
public override void Create(int numBuffers)
{
waveHeaderSize = Marshal.SizeOf(default(WaveHeader));
headers = Marshal.AllocHGlobal(waveHeaderSize * numBuffers);
dataHandles = new IntPtr[numBuffers];
dataSizes = new int[numBuffers];
for (int i = 0; i < numBuffers; i++)
{
WaveHeader *hdr = (WaveHeader *)headers + i;
hdr->Flags = WaveHeaderFlags.Done;
}
NumBuffers = numBuffers;
}
public override bool IsCompleted(int index)
{
WaveHeader *hdr = (WaveHeader *)headers + index;
if ((hdr->Flags & WaveHeaderFlags.Done) == 0)
{
return(false);
}
if ((hdr->Flags & WaveHeaderFlags.Prepared) != 0)
{
uint result = WinMM.waveOutUnprepareHeader(devHandle, (IntPtr)hdr, waveHeaderSize);
CheckError(result, "UnprepareHeader");
}
return(true);
}
public override void BufferData(int index, AudioChunk chunk)
{
if (chunk.Length > dataSizes[index])
{
IntPtr ptr = dataHandles[index];
if (ptr != IntPtr.Zero)
{
Marshal.FreeHGlobal(ptr);
}
dataHandles[index] = Marshal.AllocHGlobal(chunk.Length);
}
IntPtr handle = dataHandles[index];
fixed(byte *data = chunk.Data)
{
MemUtils.memcpy((IntPtr)data, handle, chunk.Length);
ApplyVolume(handle, chunk);
}
WaveHeader header = default(WaveHeader);
header.DataBuffer = handle;
header.BufferLength = chunk.Length;
header.Loops = 1;
WaveHeader *hdr = (WaveHeader *)headers + index;
*hdr = header;
uint result = WinMM.waveOutPrepareHeader(devHandle, (IntPtr)hdr, waveHeaderSize);
CheckError(result, "PrepareHeader");
result = WinMM.waveOutWrite(devHandle, (IntPtr)hdr, waveHeaderSize);
CheckError(result, "Write");
}
