642 lines
16 KiB
C
642 lines
16 KiB
C
|
/*
|
||
|
|
* @Doc DMusic16
|
||
|
|
*
|
||
|
|
* @Module Device.c - Device management routines |
|
||
|
|
*
|
||
|
|
* This module manages handles and handle instances to the legacy MIDI device.
|
||
|
|
*
|
||
|
|
* Each open device is represented by a handle (which is
|
||
|
|
* an <c OPENHANDLE> struct). This struct contains all of the information
|
||
|
|
* concerning the state of the device, including a reference count of the
|
||
|
|
* number of clients using the device.
|
||
|
|
*
|
||
|
|
* Each client use of one device is represented by a handle instance (which
|
||
|
|
* is an <c OPENHANDLINSTANCE> struct). A near pointer to this struct is
|
||
|
|
* the actual handle seen by the client. These handle instances are used
|
||
|
|
* to hold any client-specific information, and to dereference client
|
||
|
|
* handles to the proper <c OPENHANDLE> struct.
|
||
|
|
*
|
||
|
|
* Currently we support multiple clients on the same output device but
|
||
|
|
* only one client per input device.
|
||
|
|
*
|
||
|
|
* @globalv NPLINKNODE | gOpenHandleInstanceList | The master list of all
|
||
|
|
* open handle instances.
|
||
|
|
*
|
||
|
|
* @globalv NPLINKNODE | gOpenHandleList | The master list of all open
|
||
|
|
* handles.
|
||
|
|
*
|
||
|
|
* @globalv UINT | gcOpenInputDevices | A reference count of open MIDI
|
||
|
|
* in devices.
|
||
|
|
*
|
||
|
|
* @globalv UINT | gcOpenOutputDevices | A reference count of open MIDI
|
||
|
|
* out devices.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <windows.h>
|
||
|
|
#include <mmsystem.h>
|
||
|
|
|
||
|
|
#include "dmusic16.h"
|
||
|
|
#include "debug.h"
|
||
|
|
|
||
|
|
NPLINKNODE gOpenHandleInstanceList;
|
||
|
|
NPLINKNODE gOpenHandleList;
|
||
|
|
UINT gcOpenInputDevices;
|
||
|
|
UINT gcOpenOutputDevices;
|
||
|
|
|
||
|
|
STATIC VOID PASCAL UpdateSegmentLocks(BOOL fIsOutput);
|
||
|
|
|
||
|
|
#pragma alloc_text(INIT_TEXT, DeviceOnLoad)
|
||
|
|
#pragma alloc_text(FIX_COMM_TEXT, IsValidHandle)
|
||
|
|
|
||
|
|
/* @func Called at DLL LibInit
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* Initialize the handle lists to empty and clear the device reference counts.
|
||
|
|
*/
|
||
|
|
VOID PASCAL
|
||
|
|
DeviceOnLoad(VOID)
|
||
|
|
{
|
||
|
|
gOpenHandleInstanceList = NULL;
|
||
|
|
gOpenHandleList = NULL;
|
||
|
|
|
||
|
|
gcOpenInputDevices = 0;
|
||
|
|
gcOpenOutputDevices = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Open a device
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function is thunked to the 32-bit peer.
|
||
|
|
*
|
||
|
|
* This function allocates an <c OPENHANDLEINSTANCE> struct on behalf of the caller.
|
||
|
|
* If the requested device is already open and is an output device, the device's
|
||
|
|
* reference count will be incremented an no other action is taken. If the requested
|
||
|
|
* device is already open and is an input device, then the open will fail.
|
||
|
|
*
|
||
|
|
* If a non-DirectMusic application has the requested device open, then the
|
||
|
|
* open will fail regardless of device type.
|
||
|
|
*
|
||
|
|
* If this open is the first input or output device opened, then it will
|
||
|
|
* page lock the appropriate segments containing callback code and data.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
* @flag MMSYSERR_NOMEM | If there was insufficient memory to allocate
|
||
|
|
* the tracking structure.
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_BADDEVICEID | If the given device ID was out of range.
|
||
|
|
* @flag MMSYSERR_ALLOCATED | The specified device is already open.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
MMRESULT WINAPI
|
||
|
|
OpenLegacyDevice(
|
||
|
|
UINT id, /* @parm MMSYSTEM id of device to open */
|
||
|
|
BOOL fIsOutput, /* @parm TRUE if this is an output device */
|
||
|
|
BOOL fShare, /* @parm TRUE if the device should be shareable */
|
||
|
|
LPHANDLE ph) /* @parm Pointer where handle will be returned */
|
||
|
|
/* on success. */
|
||
|
|
{
|
||
|
|
NPOPENHANDLEINSTANCE pohi;
|
||
|
|
NPLINKNODE pLink;
|
||
|
|
NPOPENHANDLE poh;
|
||
|
|
MMRESULT mmr;
|
||
|
|
|
||
|
|
DPF(2, "OpenLegacyDevice(%d,%s,%s)",
|
||
|
|
(UINT)id,
|
||
|
|
(LPSTR)(fIsOutput ? "Output" : "Input"),
|
||
|
|
(LPSTR)(fShare ? "Shared" : "Exclusive"));
|
||
|
|
|
||
|
|
*ph = (HANDLE)NULL;
|
||
|
|
|
||
|
|
/* Sharing capture device is not allowed.
|
||
|
|
*/
|
||
|
|
if ((!fIsOutput) && (fShare))
|
||
|
|
{
|
||
|
|
return MMSYSERR_ALLOCATED;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Make sure id is in the valid range of devices
|
||
|
|
*/
|
||
|
|
if (fIsOutput)
|
||
|
|
{
|
||
|
|
if (id != MIDI_MAPPER &&
|
||
|
|
id >= midiOutGetNumDevs())
|
||
|
|
{
|
||
|
|
return MMSYSERR_BADDEVICEID;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (id >= midiInGetNumDevs())
|
||
|
|
{
|
||
|
|
return MMSYSERR_BADDEVICEID;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Create an open handle instance. This will be returned to
|
||
|
|
* Win32 as the handle.
|
||
|
|
*/
|
||
|
|
pohi = (NPOPENHANDLEINSTANCE)LocalAlloc(LPTR, sizeof(OPENHANDLEINSTANCE));
|
||
|
|
if (NULL == pohi)
|
||
|
|
{
|
||
|
|
return MMSYSERR_NOMEM;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Search through the handles we already have open and try
|
||
|
|
* to find the handle already open.
|
||
|
|
*/
|
||
|
|
mmr = MMSYSERR_NOERROR;
|
||
|
|
for (pLink = gOpenHandleList; pLink; pLink = pLink->pNext)
|
||
|
|
{
|
||
|
|
poh = (NPOPENHANDLE)pLink;
|
||
|
|
|
||
|
|
if (poh->id != id)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((fIsOutput && (!(poh->wFlags & OH_F_MIDIIN))) ||
|
||
|
|
((!fIsOutput) && (poh->wFlags & OH_F_MIDIIN)))
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* If we didn't find it, try to allocate it.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
if (NULL == pLink)
|
||
|
|
{
|
||
|
|
poh = (NPOPENHANDLE)LocalAlloc(LPTR, sizeof(OPENHANDLE));
|
||
|
|
if (NULL == poh)
|
||
|
|
{
|
||
|
|
LocalFree((HLOCAL)pohi);
|
||
|
|
return MMSYSERR_NOMEM;
|
||
|
|
}
|
||
|
|
|
||
|
|
poh->uReferenceCount = 1;
|
||
|
|
poh->id = id;
|
||
|
|
poh->wFlags = (fIsOutput ? 0 : OH_F_MIDIIN);
|
||
|
|
if (fShare)
|
||
|
|
{
|
||
|
|
poh->wFlags |= OH_F_SHARED;
|
||
|
|
}
|
||
|
|
InitializeCriticalSection(&poh->wCritSect);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
poh = (NPOPENHANDLE)pLink;
|
||
|
|
|
||
|
|
/* Validate sharing modes match.
|
||
|
|
* If they want exclusive mode, fail.
|
||
|
|
* If the device is already open in exclusive mode, fail.
|
||
|
|
*/
|
||
|
|
if (!fShare)
|
||
|
|
{
|
||
|
|
DPF(0, "Legacy open failed: non-shared open request, port already open.");
|
||
|
|
LocalFree((HLOCAL)pohi);
|
||
|
|
return MIDIERR_BADOPENMODE;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!(poh->wFlags & OH_F_SHARED))
|
||
|
|
{
|
||
|
|
DPF(0, "Legacy open failed: Port already open in exclusive mode.");
|
||
|
|
LocalFree((HLOCAL)pohi);
|
||
|
|
return MIDIERR_BADOPENMODE;
|
||
|
|
}
|
||
|
|
|
||
|
|
++poh->uReferenceCount;
|
||
|
|
}
|
||
|
|
|
||
|
|
pohi->pHandle = poh;
|
||
|
|
pohi->fActive = FALSE;
|
||
|
|
pohi->wTask = GetCurrentTask();
|
||
|
|
|
||
|
|
/* We lock segments here so we minimize the impacy of activation. However,
|
||
|
|
* actual device open is tied to activation.
|
||
|
|
*/
|
||
|
|
if (fIsOutput)
|
||
|
|
{
|
||
|
|
++gcOpenOutputDevices;
|
||
|
|
mmr = MidiOutOnOpen(pohi);
|
||
|
|
if (mmr)
|
||
|
|
{
|
||
|
|
--gcOpenOutputDevices;
|
||
|
|
}
|
||
|
|
UpdateSegmentLocks(fIsOutput);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
++gcOpenInputDevices;
|
||
|
|
mmr = MidiInOnOpen(pohi);
|
||
|
|
if (mmr)
|
||
|
|
{
|
||
|
|
--gcOpenInputDevices;
|
||
|
|
}
|
||
|
|
UpdateSegmentLocks(fIsOutput);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (poh->uReferenceCount == 1)
|
||
|
|
{
|
||
|
|
ListInsert(&gOpenHandleList, &poh->link);
|
||
|
|
}
|
||
|
|
|
||
|
|
ListInsert(&gOpenHandleInstanceList, &pohi->link);
|
||
|
|
ListInsert(&poh->pInstanceList, &pohi->linkHandleList);
|
||
|
|
|
||
|
|
*ph = (HANDLE)(DWORD)(WORD)pohi;
|
||
|
|
|
||
|
|
return MMSYSERR_NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Close a legacy device
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function is thunked to the 32-bit peer.
|
||
|
|
*
|
||
|
|
* It just validates the handle and calls the internal close device API.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_INVALHANDLE | If the passed handle was not recognized.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
MMRESULT WINAPI
|
||
|
|
CloseLegacyDevice(
|
||
|
|
HANDLE h) /* @parm The handle to close. */
|
||
|
|
{
|
||
|
|
NPOPENHANDLEINSTANCE pohi = (NPOPENHANDLEINSTANCE)(WORD)h;
|
||
|
|
|
||
|
|
DPF(2, "CloseLegacyDevice %04X\n", h);
|
||
|
|
|
||
|
|
if (!IsValidHandle(h, VA_F_EITHER, &pohi))
|
||
|
|
{
|
||
|
|
DPF(0, "CloseLegacyDevice: Invalid handle\n");
|
||
|
|
return MMSYSERR_INVALHANDLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return CloseLegacyDeviceI(pohi);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Activate or deactivate a legacy device
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function is thunked to the 32-bit peer.
|
||
|
|
*
|
||
|
|
* Validate parameters and pass the call to the internal activate.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
* @flag MMSYSERR_INVALHANDLE | If the passed handle was not recognized.
|
||
|
|
* Any other MMRESULT that a midiXxx call might return.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
MMRESULT WINAPI
|
||
|
|
ActivateLegacyDevice(
|
||
|
|
HANDLE h,
|
||
|
|
BOOL fActivate)
|
||
|
|
{
|
||
|
|
NPOPENHANDLEINSTANCE pohi;
|
||
|
|
|
||
|
|
if (!IsValidHandle(h, VA_F_EITHER, &pohi))
|
||
|
|
{
|
||
|
|
DPF(0, "Activate: Invalid handle\n");
|
||
|
|
return MMSYSERR_INVALHANDLE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ActivateLegacyDeviceI(pohi, fActivate);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Close a legacy device (internal)
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function deallocates the referenced <c OPENHANDLEINSTANCE> struct.
|
||
|
|
* If it is the last reference to the device, then the device will be closed
|
||
|
|
* as well.
|
||
|
|
*
|
||
|
|
* If this is the last input or output device being closed, then the
|
||
|
|
* appropriate segments containing callback code and data will be
|
||
|
|
* unlocked.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
MMRESULT PASCAL
|
||
|
|
CloseLegacyDeviceI(
|
||
|
|
NPOPENHANDLEINSTANCE pohi)
|
||
|
|
{
|
||
|
|
NPOPENHANDLE poh;
|
||
|
|
|
||
|
|
/* Deactivate this device. This might result in the device being closed.
|
||
|
|
*/
|
||
|
|
ActivateLegacyDeviceI(pohi, FALSE);
|
||
|
|
|
||
|
|
poh = pohi->pHandle;
|
||
|
|
ListRemove(&gOpenHandleInstanceList, &pohi->link);
|
||
|
|
ListRemove(&poh->pInstanceList, &pohi->linkHandleList);
|
||
|
|
|
||
|
|
--poh->uReferenceCount;
|
||
|
|
if (poh->wFlags & OH_F_MIDIIN)
|
||
|
|
{
|
||
|
|
--gcOpenInputDevices;
|
||
|
|
MidiInOnClose(pohi);
|
||
|
|
UpdateSegmentLocks(FALSE /*fIsOutput*/);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
--gcOpenOutputDevices;
|
||
|
|
MidiOutOnClose(pohi);
|
||
|
|
UpdateSegmentLocks(TRUE /*fIsOutput*/);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (0 == poh->uReferenceCount)
|
||
|
|
{
|
||
|
|
ListRemove(&gOpenHandleList, &poh->link);
|
||
|
|
LocalFree((HLOCAL)poh);
|
||
|
|
}
|
||
|
|
|
||
|
|
LocalFree((HLOCAL)pohi);
|
||
|
|
|
||
|
|
return MMSYSERR_NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Activate or deactivate a legacy device (internal)
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function is thunked to the 32-bit peer.
|
||
|
|
*
|
||
|
|
* Handle open and close of the device on first activate and last deactivate.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
*
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
* @flag MMSYSERR_INVALHANDLE | If the passed handle was not recognized.
|
||
|
|
* Any other MMRESULT that a midiXxx call might return.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
MMRESULT PASCAL
|
||
|
|
ActivateLegacyDeviceI(
|
||
|
|
NPOPENHANDLEINSTANCE pohi,
|
||
|
|
BOOL fActivate)
|
||
|
|
{
|
||
|
|
NPOPENHANDLE poh;
|
||
|
|
MMRESULT mmr;
|
||
|
|
|
||
|
|
poh = pohi->pHandle;
|
||
|
|
|
||
|
|
if (fActivate)
|
||
|
|
{
|
||
|
|
if (pohi->fActive)
|
||
|
|
{
|
||
|
|
DPF(0, "Activate: Activating already active handle %04X", pohi);
|
||
|
|
return MMSYSERR_NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
poh->uActiveCount++;
|
||
|
|
|
||
|
|
if (poh->wFlags & OH_F_MIDIIN)
|
||
|
|
{
|
||
|
|
mmr = MidiInOnActivate(pohi);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
mmr = MidiOutOnActivate(pohi);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mmr == MMSYSERR_NOERROR)
|
||
|
|
{
|
||
|
|
pohi->fActive = TRUE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
--poh->uActiveCount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!pohi->fActive)
|
||
|
|
{
|
||
|
|
DPF(0, "Activate: Deactivating already inactive handle %04X", pohi);
|
||
|
|
return MMSYSERR_NOERROR;
|
||
|
|
}
|
||
|
|
|
||
|
|
pohi->fActive = TRUE;
|
||
|
|
poh->uActiveCount--;
|
||
|
|
|
||
|
|
if (poh->wFlags & OH_F_MIDIIN)
|
||
|
|
{
|
||
|
|
mmr = MidiInOnDeactivate(pohi);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
mmr = MidiOutOnDeactivate(pohi);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mmr == MMSYSERR_NOERROR)
|
||
|
|
{
|
||
|
|
pohi->fActive = FALSE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
--poh->uActiveCount;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return mmr;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Validate the given handle
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* Determine if the given handle is valid, and if so, return the open handle instance.
|
||
|
|
*
|
||
|
|
* The handle is merely a pointer to an <c OPENHANDLEINSTANCE> struct. This function,
|
||
|
|
* in the debug build, will verify that the handle actually points to a struct allocated
|
||
|
|
* by this DLL. In all builds, the handle type will be verified.
|
||
|
|
*
|
||
|
|
* @rdesc Returns one of the following:
|
||
|
|
* @flag MMSYSERR_NOERROR | On success
|
||
|
|
* @flag MMSYSERR_INVALHANDLE | If the given handle is invalid or of the wrong type.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
BOOL PASCAL
|
||
|
|
IsValidHandle(
|
||
|
|
HANDLE h, /* @parm The handle to verify */
|
||
|
|
WORD wType, /* @parm The required type of handle. One of the following: */
|
||
|
|
/* @flag VA_F_INPUT | If the handle must specify an input device */
|
||
|
|
/* @flag VA_F_OUTPUT | If the handle must specify an output device */
|
||
|
|
/* @flag VA_F_EITHER | If either type of handle is acceptable */
|
||
|
|
NPOPENHANDLEINSTANCE FAR *lppohi) /* @parm Will contain the open handle instance on return */
|
||
|
|
{
|
||
|
|
#ifdef DEBUG
|
||
|
|
NPLINKNODE pLink;
|
||
|
|
#endif
|
||
|
|
NPOPENHANDLEINSTANCE pohi = (NPOPENHANDLEINSTANCE)(WORD)h;
|
||
|
|
|
||
|
|
#ifdef DEBUG
|
||
|
|
/* Find the handle instance in the global list
|
||
|
|
*/
|
||
|
|
for (pLink = gOpenHandleInstanceList; pLink; pLink = pLink->pNext)
|
||
|
|
{
|
||
|
|
DPF(2, "IsValidHandle: Theirs %04X mine %04X", (WORD)h, (WORD)pLink);
|
||
|
|
if (pLink == (NPLINKNODE)(WORD)h)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (NULL == pLink)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
DPF(2, "IsValidHandle: Got handle, flags are %04X", pohi->pHandle->wFlags);
|
||
|
|
|
||
|
|
*lppohi = pohi;
|
||
|
|
|
||
|
|
/* Verify the handle type
|
||
|
|
*/
|
||
|
|
if (pohi->pHandle->wFlags & OH_F_MIDIIN)
|
||
|
|
{
|
||
|
|
if (wType & VA_F_INPUT)
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (wType & VA_F_OUTPUT)
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
*lppohi = NULL;
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
/* @func Lock or unlock segments as need be.
|
||
|
|
*
|
||
|
|
* @comm
|
||
|
|
*
|
||
|
|
* This function calls the DLL's Lock and Unlock functions to bring the lock status
|
||
|
|
* of the segments containing callback code and data into sync with the actual types
|
||
|
|
* of devices currently open. This prevents having too much memory page locked when
|
||
|
|
* it is not actually being used.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
STATIC VOID PASCAL
|
||
|
|
UpdateSegmentLocks(
|
||
|
|
BOOL fIsOutput) /* @parm TRUE if the last device opened or closed was an output device */
|
||
|
|
{
|
||
|
|
if (fIsOutput)
|
||
|
|
{
|
||
|
|
switch(gcOpenOutputDevices)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
if (gcOpenInputDevices)
|
||
|
|
{
|
||
|
|
DPF(2, "Unlocking output");
|
||
|
|
UnlockCode(LOCK_F_OUTPUT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DPF(2, "Unlocking output+common");
|
||
|
|
UnlockCode(LOCK_F_OUTPUT | LOCK_F_COMMON);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 1:
|
||
|
|
if (gcOpenInputDevices)
|
||
|
|
{
|
||
|
|
DPF(2, "Locking output");
|
||
|
|
LockCode(LOCK_F_OUTPUT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DPF(2, "Locking output+common");
|
||
|
|
LockCode(LOCK_F_OUTPUT | LOCK_F_COMMON);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
switch(gcOpenInputDevices)
|
||
|
|
{
|
||
|
|
case 0:
|
||
|
|
if (gcOpenOutputDevices)
|
||
|
|
{
|
||
|
|
DPF(2, "Unlocking input");
|
||
|
|
UnlockCode(LOCK_F_INPUT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DPF(2, "Unlocking input+common");
|
||
|
|
UnlockCode(LOCK_F_INPUT | LOCK_F_COMMON);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
|
||
|
|
case 1:
|
||
|
|
if (gcOpenOutputDevices)
|
||
|
|
{
|
||
|
|
DPF(2, "Locking input");
|
||
|
|
LockCode(LOCK_F_INPUT);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DPF(2, "Locking input+common");
|
||
|
|
LockCode(LOCK_F_INPUT | LOCK_F_COMMON);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/* @func Clean up all open handles held by a given task
|
||
|
|
*
|
||
|
|
* @comm This function is called when a task terminates. It will clean up resources left
|
||
|
|
* behind by a process which did not terminate cleanly, and therefore did not tell
|
||
|
|
* this DLL to unload in its context.
|
||
|
|
*/
|
||
|
|
VOID PASCAL
|
||
|
|
CloseDevicesForTask(
|
||
|
|
WORD wTask)
|
||
|
|
{
|
||
|
|
NPLINKNODE pLink;
|
||
|
|
NPOPENHANDLEINSTANCE pohi;
|
||
|
|
|
||
|
|
for (pLink = gOpenHandleInstanceList; pLink; pLink = pLink->pNext)
|
||
|
|
{
|
||
|
|
pohi = (NPOPENHANDLEINSTANCE)pLink;
|
||
|
|
|
||
|
|
if (pohi->wTask != wTask)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
DPF(0, "CloseDevicesForTask: Closing %04X", (WORD)pohi);
|
||
|
|
/* NOTE: This will free pohi
|
||
|
|
*/
|
||
|
|
CloseLegacyDeviceI(pohi);
|
||
|
|
|
||
|
|
pLink = gOpenHandleInstanceList;
|
||
|
|
}
|
||
|
|
}
|