int GMSynthDLL::ThreadProc()
{
if (live)
{
if (seqMode & seqPlay)
ldTm = 0.02;
else
ldTm = 0.20;
OpenWaveDevice();
inmgr.SetWaveOut(&wvd);
}
else
{
if (wvf.OpenWaveFile(outFileName, 2))
{
OnEvent(SEQEVT_SEQSTOP, NULL);
return GMSYNTH_ERR_FILEOPEN;
}
inmgr.SetWaveOut(&wvf);
}
inmgr.Reset();
seq.SequenceMulti(inmgr, stTime, endTime, seqMode);
if (live)
{
bsInt32 drain = (bsInt32) (synthParams.sampleRate * (ldTm * 4));
while (--drain > 0)
inmgr.Tick();
CloseWaveDevice();
}
else
wvf.CloseWaveFile();
return GMSYNTH_NOERROR;
}
BOOL DllEntryPoint(HINSTANCE hInstance, DWORD Reason, LPVOID Reserved)
{
switch (Reason) {
case DLL_PROCESS_ATTACH:
GlobalhInstance = hInstance;
InitializeCriticalSection(&WaveDeviceCritSec);
/*
* Find suitable wave devices
*/
WaveInDevice = FindDevice(TRUE);
WaveOutDevice = FindDevice(FALSE);
/*
* Must at least have a wave out device!
*/
if (WaveOutDevice == NO_DEVICE_FOUND) {
return FALSE;
}
if (!InstallIoHook(hInstance)) {
dprintf2(("VDD failed to load"));
return FALSE;
} else {
dprintf2(("Loaded at port %3X", BasePort));
return TRUE;
}
case DLL_PROCESS_DETACH:
dprintf2(("Process detaching"));
CloseWaveDevice();
DeInstallIoHook(hInstance);
DeleteCriticalSection(&WaveDeviceCritSec);
return TRUE;
case DLL_THREAD_ATTACH:
dprintf2(("Connecting to thread %X", GetCurrentThreadId()));
return TRUE;
case DLL_THREAD_DETACH:
dprintf2(("Sound blaster VDD detaching from thread %X", GetCurrentThreadId()));
return TRUE;
default:
return TRUE;
}
}
BOOL StartTransfer(BOOL InputOrOutput, BOOL NewAuto)
{
PBYTE DMATransferAddress;
/*
* Set the status to see if more apps will work
*/
WriteStatus = 0xFF;
/*
* We find where the data is - we know how long it is from
* the block size
*/
DMATransferAddress = GetTransferAddress();
dprintf2(("Starting transfer from %8X", (DWORD)DMATransferAddress));
if (DMATransferAddress == (PBYTE)(-1L)) {
return FALSE;
}
#if DBG
if (VddDebugLevel >= 3) {
int i;
for (i = 0; i < 64; i+= 8) {
dprintf(("Data : %2X %2X %2X %2X %2X %2X %2X %2X",
((PBYTE)DMATransferAddress)[i],
((PBYTE)DMATransferAddress)[i + 1],
((PBYTE)DMATransferAddress)[i + 2],
((PBYTE)DMATransferAddress)[i + 3],
((PBYTE)DMATransferAddress)[i + 4],
((PBYTE)DMATransferAddress)[i + 5],
((PBYTE)DMATransferAddress)[i + 6],
((PBYTE)DMATransferAddress)[i + 7]));
}
}
#endif //DBG
/*
* If we're changing our type of device
*/
if (InputOrOutput != Input) {
dprintf3(("Direction changed - close device"));
CloseWaveDevice();
Input = InputOrOutput;
}
/*
* Start the device if possible
*/
KillWaveDevice();
Auto = NewAuto;
if (Auto) {
BlockSize /= 2;
}
if (SetupWave(DMATransferAddress)) {
/*
* Set the device as requesting
*/
SetTerminalCount(TRUE);
}
}
void MyByteOut(WORD port, BYTE data)
{
dprintf3(("Received write to Port %4X, Data %2X", port, data));
switch (port - BasePort) {
case RESET_PORT:
if (data == 1) {
ResetState = Reset1Written;
} else {
if (ResetState == Reset1Written && data == 0) {
ResetState = ResetNotStarted;
/*
* OK - reset everything
*/
CloseWaveDevice();
/*
* Reset state machines
*/
DSPReadState = Reset;
DSPWriteState = WriteCommand;
GetVersionFirst = TRUE;
}
}
break;
case WRITE_PORT:
/*
* Use the state to see if it's data
*/
switch (DSPWriteState) {
case WriteCommand:
WriteCommandByte(data);
break;
case CardIdent:
IdentByte = data;
DSPReadState = ReadIdent;
DSPWriteState = WriteCommand;
break;
case SetTimeConstant:
TimeConstant = (DWORD)data;
dprintf2(("Set sampling rate %d", GetSamplingRate()));
DSPWriteState = WriteCommand;
break;
case BlockSizeFirstByte:
SBBlockSize = (DWORD)data;
DSPWriteState = BlockSizeSecondByte;
break;
case BlockSizeSecondByte:
SBBlockSize = SBBlockSize + ((DWORD)data << 8) + 1;
DSPWriteState = WriteCommand;
dprintf2(("Block size set to 0x%x", SBBlockSize));
break;
case BlockSizeFirstByteWrite:
SBBlockSize = (DWORD)data;
DSPWriteState = BlockSizeSecondByteWrite;
break;
case BlockSizeSecondByteWrite:
SBBlockSize = SBBlockSize + ((DWORD)data << 8) + 1;
DSPWriteState = WriteCommand;
StartTransfer(FALSE, FALSE);
break;
case BlockSizeFirstByteRead:
SBBlockSize = (DWORD)data;
DSPWriteState = BlockSizeSecondByteRead;
break;
case BlockSizeSecondByteRead:
SBBlockSize = SBBlockSize + ((DWORD)data << 8) + 1;
DSPWriteState = WriteCommand;
StartTransfer(TRUE, FALSE);
break;
case DirectWaveOut:
case MidiWrite:
/*
* Just discard for now
*/
DSPWriteState = WriteCommand;
break;
}
break;
}
}
BOOL SetupWave(PVOID TransferAddress)
{
DWORD SampleRate;
UINT rc;
/*
* Make sure we've got a device - we may have one which does
* not match the current sampling rate.
*/
if (TimeConstant != 0xFFFF) {
SampleRate = GetSamplingRate();
if (SampleRate != WaveFormat.wf.nSamplesPerSec) {
/*
* Search for a suitable format
*/
if (!TestWaveFormat(SampleRate)) {
/*
* If this did not work it may be too fast
* or slow so move it into our compass
*/
if (SampleRate > 22050) {
SampleRate = 22050;
} else {
if (SampleRate < 11025) {
SampleRate = 11025;
}
}
/*
* Device may only support discrete rates
*/
if (!TestWaveFormat(SampleRate)) {
if (SampleRate > (11025 + 22050) / 2) {
SampleRate == 22050;
} else {
SampleRate = 11025;
}
}
}
/*
* Open the device with the new format if it's changed
*/
if (SampleRate != WaveFormat.wf.nSamplesPerSec) {
dprintf3(("Format changed"));
CloseWaveDevice();
WaveFormat.wf.nSamplesPerSec = SampleRate;
WaveFormat.wf.nAvgBytesPerSec = SampleRate;
dprintf2(("Setting %d samples per second", SampleRate));
}
}
TimeConstant = 0xFFFF;
}
if (hWave == NULL) {
dprintf3(("Opening wave device"));
OpenWaveDevice();
} else {
dprintf3(("Resetting wave device prior to play"));
(Input ? waveInReset : waveOutReset)(hWave);
}
/*
* Set up any wave buffers etc if necessary
*/
if (hWave) {
if (WaveHdr[0].lpData != (LPSTR)TransferAddress ||
BlockSize != WaveHdr[0].dwBufferLength) {
(Input ? waveInUnprepareHeader : waveOutUnprepareHeader)
(hWave, &WaveHdr[0], sizeof(WAVEHDR));
if (WaveHdr[1].dwFlags & WHDR_PREPARED) {
(Input ? waveInUnprepareHeader : waveOutUnprepareHeader)
(hWave, &WaveHdr[1], sizeof(WAVEHDR));
}
}
WaveHdr[0].lpData = (LPSTR)TransferAddress;
WaveHdr[0].dwBufferLength = BlockSize;
WaveHdr[1].lpData = (LPSTR)TransferAddress + BlockSize;
WaveHdr[1].dwBufferLength = BlockSize;
if (Auto && AutoThread == NULL) {
dprintf3(("Creating event"));
if (AutoEvent == NULL) {
AutoEvent = CreateEvent(NULL, 0, 0, NULL);
if (AutoEvent != NULL) {
DWORD Id;
dprintf2(("Creating thread"));
AutoThread = CreateThread(NULL,
300,
AutoThreadEntry,
NULL,
0,
&Id);
if (AutoThread == NULL) {
dprintf2(("Create thread failed code %d",
GetLastError()));
}
} else {
dprintf2(("Create event failed code %d",
GetLastError()));
}
}
}
if (!(WaveHdr[0].dwFlags & WHDR_PREPARED)) {
(Input ? waveInPrepareHeader : waveOutPrepareHeader)
(hWave, &WaveHdr[0], sizeof(WAVEHDR));
}
if (Auto) {
if (!(WaveHdr[1].dwFlags & WHDR_PREPARED)) {
(Input ? waveInPrepareHeader : waveOutPrepareHeader)
(hWave, &WaveHdr[1], sizeof(WAVEHDR));
}
}
/*
* Actually do it!
*/
dprintf2(("Writing %d bytes to wave device",
WaveHdr[0].dwBufferLength));
rc = (Input ? waveInAddBuffer : waveOutWrite)
(hWave, &WaveHdr[0], sizeof(WAVEHDR));
if (rc != MMSYSERR_NOERROR) {
dprintf1(("Failed to write to /read from wave device - %d", rc));
}
if (Auto) {
(Input ? waveInAddBuffer : waveOutWrite)
(hWave, &WaveHdr[1], sizeof(WAVEHDR));
}
if (Input) {
waveInStart(hWave);
}
}
return TRUE;
}
