Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

265 lines
7.1 KiB

/*******************************Module*Header*********************************\
* Module Name: support.c
*
* MultiMedia Systems MCIWAVE DLL
*
* Created: 27-Feb-1992
* Author: ROBINSP
*
* History:
*
* Copyright (c) 1985-1996 Microsoft Corporation
*
\******************************************************************************/
#define UNICODE
#include <windows.h>
#include <mciwave.h>
STATICDT CRITICAL_SECTION CritSec;
#if DBG
STATICDT UINT cCritSec = 0;
DWORD dwCritSecOwner = 0;
#endif
/*************************************************************************
*
* Cut-down critical section stuff
*
* This critical section is used to simulate windows tasking
* The owner of the critical section runs exclusively in this
* DLL.
*
* At the front of each function request the critical section is
* grabbed and only release on mmYield or TaskBlock.
*
* Extra 'tasks' (threads) per device hold the critical section when
* they are working.
*
* This method has been used to simplify porting the code from
* windows. A rewrite would use a different mechanism.
*
************************************************************************/
VOID InitCrit(VOID)
{
InitializeCriticalSection(&CritSec);
}
VOID DeleteCrit(VOID)
{
DeleteCriticalSection(&CritSec);
}
#if DBG
VOID DbgEnterCrit(UINT ln, LPCSTR lpszFile)
{
BOOL fPossibleWait;
if (dwCritSecOwner) {
dprintf3(("Critical section owned by thread %x", dwCritSecOwner));
fPossibleWait = TRUE;
} else {
fPossibleWait = FALSE;
}
EnterCriticalSection(&CritSec);
if (fPossibleWait) {
dprintf2(("...entered critical section after possible wait"));
}
if (!cCritSec++) {
// This is the first time into the critcal section
dwCritSecOwner = GetCurrentThreadId();
dprintf3(("...entered critical section (%d) at line %d in file %s", cCritSec, ln, lpszFile));
} else {
dprintf1(("Reentering critical section, count = %d", cCritSec));
WinAssert(0);
// Note: if the memory allocation stuff starts to be synchronised
// then this assertion becomes invalid.
}
}
#else
VOID EnterCrit(VOID)
{
EnterCriticalSection(&CritSec);
}
#endif
VOID LeaveCrit(VOID)
{
#if DBG
if (!--cCritSec) {
// Relinquishing control of the critcal section
dwCritSecOwner = 0;
dprintf2(("...relinquished critical section (%d)",cCritSec));
} else {
dprintf3(("Leaving critical section, count = %d", cCritSec));
}
#endif
LeaveCriticalSection(&CritSec);
}
/*************************************************************************
*
* @doc MCIWAVE
*
* @func UINT | TaskBlock | This function blocks the current
* task context if its event count is 0.
*
* @rdesc Returns the message value of the signal sent.
*
************************************************************************/
UINT TaskBlock(VOID)
{
MSG msg;
dprintf3(("Thread %x blocking", GetCurrentThreadId()));
LeaveCrit();
/*
* Loop until we get the message we want
*/
for (;;) {
/*
* Retrieve any message for task
*/
GetMessage(&msg, NULL, 0, 0);
/*
* If the message is for a window dispatch it
*/
if (msg.hwnd != NULL) {
DispatchMessage(&msg);
} else {
if (msg.message != WM_USER &&
msg.message != WTM_STATECHANGE) {
dprintf1(("Got thread message %8X", msg.message));
}
//
// Because MCIWAVE background task can't cope with getting
// random(?) messages like MM_WIM_DATA because it thinks that
// WM_USER IS its MM_WIM_DATA. Let the expected WM_USER
// messages go through, but trap the MM_WIM_DATA so that
// MCIWAVE's buffers don't get all messed up.
//
if (msg.message != MM_WIM_DATA)
break;
}
}
dprintf3(("TaskBlock returning with message 0x%x", msg.message));
EnterCrit();
return msg.message;
}
/*************************************************************************
*
* @doc MCIWAVE
*
* @func BOOL | TaskSignal | This function signals the specified
* task, incrementing its event count and unblocking
* it.
*
* @parm HANDLE | h | Task handle. For predictable results, get the
* task handle from <f mmGetCurrentTask>.
*
* @parm UINT | Msg | Signal message to send.
*
* @rdesc Returns TRUE if the signal was sent, else FALSE if the message
* queue was full.
*
* @xref mmTaskBlock mmTaskCreate
*
* @comm For predictable results, must only be called from a task
* created with <f mmTaskCreate>.
*
************************************************************************/
BOOL TaskSignal(DWORD h, UINT Msg)
{
#ifdef DBG
BOOL fErr;
dprintf2(("Signalling Thread %x", (ULONG)h));
fErr = PostThreadMessage(h, Msg, 0, 0);
if (!fErr) {
dprintf1(("Error %d signalling Thread %x", GetLastError(), (ULONG)h));
}
return(fErr);
#else
return PostThreadMessage(h, Msg, 0, 0);
#endif
}
/*************************************************************************
*
* @doc MCIWAVE
*
* @func VOID | TaskWaitComplete | This function waits for the
* specified task to terminate.
*
* @parm HANDLE | h | Task handle. For predictable results, get the
* task handle from <f mmGetCurrentTask>.
*
* @rdesc No return code
*
************************************************************************/
VOID TaskWaitComplete(HANDLE h)
{
UINT Rc;
LeaveCrit();
/* Wait (no timeout) for thread to complete */
Rc = WaitForSingleObject(h, INFINITE);
if (Rc != 0) {
dprintf(("Error terminating thread - WaitForSingleObject returned non-zero !!!"));
}
/* Note that the handle must be freed by us */
CloseHandle(h);
EnterCrit();
}
#if DBG
/*************************************************************************
*
* @doc MCIWAVE
*
* @func VOID | mmYield | This function checks that we are in the
* critical section before Yielding. If we are then the
* critical section is reentered after yielding.
*
* @parm <t>PWAVEDESC<d> | pwd |
* Pointer to the wave device descriptor.
*
* @rdesc No return code
*
************************************************************************/
VOID mmDbgYield(
PWAVEDESC pwd,
UINT ln,
LPCSTR lpszFile)
{
if (GetCurrentThreadId() != dwCritSecOwner) {
dprintf1(("mmYield called while not in the critical section from line %d in file %s", ln, lpszFile));
}
CheckIn();
LeaveCrit();
CheckOut();
Sleep(10);
EnterCrit();
}
#endif