476 lines
15 KiB
C
476 lines
15 KiB
C
/* -*- tab-width: 8; c-basic-offset: 4 -*- */
|
|
|
|
/*
|
|
* MMSYSTEM time functions
|
|
*
|
|
* Copyright 1993 Martin Ayotte
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdarg.h>
|
|
#include <time.h>
|
|
#ifdef HAVE_SYS_TIME_H
|
|
# include <sys/time.h>
|
|
#endif
|
|
#ifdef HAVE_UNISTD_H
|
|
# include <unistd.h>
|
|
#endif
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "mmsystem.h"
|
|
|
|
#include "winemm.h"
|
|
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(mmtime);
|
|
|
|
static HANDLE TIME_hMMTimer;
|
|
static LPWINE_TIMERENTRY TIME_TimersList;
|
|
static HANDLE TIME_hKillEvent;
|
|
static HANDLE TIME_hWakeEvent;
|
|
static BOOL TIME_TimeToDie = TRUE;
|
|
|
|
/*
|
|
* Some observations on the behavior of winmm on Windows.
|
|
* First, the call to timeBeginPeriod(xx) can never be used
|
|
* to raise the timer resolution, only lower it.
|
|
*
|
|
* Second, a brief survey of a variety of Win 2k and Win X
|
|
* machines showed that a 'standard' (aka default) timer
|
|
* resolution was 1 ms (Win9x is documented as being 1). However, one
|
|
* machine had a standard timer resolution of 10 ms.
|
|
*
|
|
* Further, if we set our default resolution to 1,
|
|
* the implementation of timeGetTime becomes GetTickCount(),
|
|
* and we can optimize the code to reduce overhead.
|
|
*
|
|
* Additionally, a survey of Event behaviors shows that
|
|
* if we request a Periodic event every 50 ms, then Windows
|
|
* makes sure to trigger that event 20 times in the next
|
|
* second. If delays prevent that from happening on exact
|
|
* schedule, Windows will trigger the events as close
|
|
* to the original schedule as is possible, and will eventually
|
|
* bring the event triggers back onto a schedule that is
|
|
* consistent with what would have happened if there were
|
|
* no delays.
|
|
*
|
|
* Jeremy White, October 2004
|
|
*/
|
|
#define MMSYSTIME_MININTERVAL (1)
|
|
#define MMSYSTIME_MAXINTERVAL (65535)
|
|
|
|
|
|
static void TIME_TriggerCallBack(LPWINE_TIMERENTRY lpTimer)
|
|
{
|
|
TRACE("%04lx:CallBack => lpFunc=%p wTimerID=%04X dwUser=%08lX dwTriggerTime %ld(delta %ld)\n",
|
|
GetCurrentThreadId(), lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser,
|
|
lpTimer->dwTriggerTime, GetTickCount() - lpTimer->dwTriggerTime);
|
|
|
|
/* - TimeProc callback that is called here is something strange, under Windows 3.1x it is called
|
|
* during interrupt time, is allowed to execute very limited number of API calls (like
|
|
* PostMessage), and must reside in DLL (therefore uses stack of active application). So I
|
|
* guess current implementation via SetTimer has to be improved upon.
|
|
*/
|
|
switch (lpTimer->wFlags & 0x30) {
|
|
case TIME_CALLBACK_FUNCTION:
|
|
if (lpTimer->wFlags & WINE_TIMER_IS32)
|
|
(lpTimer->lpFunc)(lpTimer->wTimerID, 0, lpTimer->dwUser, 0, 0);
|
|
else if (pFnCallMMDrvFunc16)
|
|
pFnCallMMDrvFunc16((DWORD)lpTimer->lpFunc, lpTimer->wTimerID, 0,
|
|
lpTimer->dwUser, 0, 0);
|
|
break;
|
|
case TIME_CALLBACK_EVENT_SET:
|
|
SetEvent((HANDLE)lpTimer->lpFunc);
|
|
break;
|
|
case TIME_CALLBACK_EVENT_PULSE:
|
|
PulseEvent((HANDLE)lpTimer->lpFunc);
|
|
break;
|
|
default:
|
|
FIXME("Unknown callback type 0x%04x for mmtime callback (%p), ignored.\n",
|
|
lpTimer->wFlags, lpTimer->lpFunc);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* TIME_MMSysTimeCallback
|
|
*/
|
|
static DWORD CALLBACK TIME_MMSysTimeCallback(LPWINE_MM_IDATA iData)
|
|
{
|
|
static int nSizeLpTimers;
|
|
static LPWINE_TIMERENTRY lpTimers;
|
|
|
|
LPWINE_TIMERENTRY timer, *ptimer, *next_ptimer;
|
|
int idx;
|
|
DWORD cur_time;
|
|
DWORD delta_time;
|
|
DWORD ret_time = INFINITE;
|
|
DWORD adjust_time;
|
|
|
|
|
|
/* optimize for the most frequent case - no events */
|
|
if (! TIME_TimersList)
|
|
return(ret_time);
|
|
|
|
/* since timeSetEvent() and timeKillEvent() can be called
|
|
* from 16 bit code, there are cases where win16 lock is
|
|
* locked upon entering timeSetEvent(), and then the mm timer
|
|
* critical section is locked. This function cannot call the
|
|
* timer callback with the crit sect locked (because callback
|
|
* may need to acquire Win16 lock, thus providing a deadlock
|
|
* situation).
|
|
* To cope with that, we just copy the WINE_TIMERENTRY struct
|
|
* that need to trigger the callback, and call it without the
|
|
* mm timer crit sect locked.
|
|
* the hKillTimeEvent is used to mark the section where we
|
|
* handle the callbacks so we can do synchronous kills.
|
|
* EPP 99/07/13, updated 04/01/10
|
|
*/
|
|
idx = 0;
|
|
cur_time = GetTickCount();
|
|
|
|
EnterCriticalSection(&iData->cs);
|
|
for (ptimer = &TIME_TimersList; *ptimer != NULL; ) {
|
|
timer = *ptimer;
|
|
next_ptimer = &timer->lpNext;
|
|
if (cur_time >= timer->dwTriggerTime)
|
|
{
|
|
if (timer->lpFunc) {
|
|
if (idx == nSizeLpTimers) {
|
|
if (lpTimers)
|
|
lpTimers = (LPWINE_TIMERENTRY)
|
|
HeapReAlloc(GetProcessHeap(), 0, lpTimers,
|
|
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
|
|
else
|
|
lpTimers = (LPWINE_TIMERENTRY)
|
|
HeapAlloc(GetProcessHeap(), 0,
|
|
++nSizeLpTimers * sizeof(WINE_TIMERENTRY));
|
|
}
|
|
lpTimers[idx++] = *timer;
|
|
|
|
}
|
|
|
|
/* Update the time after we make the copy to preserve
|
|
the original trigger time */
|
|
timer->dwTriggerTime += timer->wDelay;
|
|
|
|
/* TIME_ONESHOT is defined as 0 */
|
|
if (!(timer->wFlags & TIME_PERIODIC))
|
|
{
|
|
/* unlink timer from timers list */
|
|
*ptimer = *next_ptimer;
|
|
HeapFree(GetProcessHeap(), 0, timer);
|
|
|
|
/* We don't need to trigger oneshots again */
|
|
delta_time = INFINITE;
|
|
}
|
|
else
|
|
{
|
|
/* Compute when this event needs this function
|
|
to be called again */
|
|
if (timer->dwTriggerTime <= cur_time)
|
|
delta_time = 0;
|
|
else
|
|
delta_time = timer->dwTriggerTime - cur_time;
|
|
}
|
|
}
|
|
else
|
|
delta_time = timer->dwTriggerTime - cur_time;
|
|
|
|
/* Determine when we need to return to this function */
|
|
ret_time = min(ret_time, delta_time);
|
|
|
|
ptimer = next_ptimer;
|
|
}
|
|
if (TIME_hKillEvent) ResetEvent(TIME_hKillEvent);
|
|
LeaveCriticalSection(&iData->cs);
|
|
|
|
while (idx > 0) TIME_TriggerCallBack(&lpTimers[--idx]);
|
|
if (TIME_hKillEvent) SetEvent(TIME_hKillEvent);
|
|
|
|
/* Finally, adjust the recommended wait time downward
|
|
by the amount of time the processing routines
|
|
actually took */
|
|
adjust_time = GetTickCount() - cur_time;
|
|
if (adjust_time > ret_time)
|
|
ret_time = 0;
|
|
else
|
|
ret_time -= adjust_time;
|
|
|
|
/* We return the amount of time our caller should sleep
|
|
before needing to check in on us again */
|
|
return(ret_time);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* TIME_MMSysTimeThread
|
|
*/
|
|
static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg)
|
|
{
|
|
LPWINE_MM_IDATA iData = (LPWINE_MM_IDATA)arg;
|
|
DWORD sleep_time;
|
|
DWORD rc;
|
|
|
|
TRACE("Starting main winmm thread\n");
|
|
|
|
/* FIXME: As an optimization, we could have
|
|
this thread die when there are no more requests
|
|
pending, and then get recreated on the first
|
|
new event; it's not clear if that would be worth
|
|
it or not. */
|
|
|
|
while (! TIME_TimeToDie)
|
|
{
|
|
sleep_time = TIME_MMSysTimeCallback(iData);
|
|
|
|
if (sleep_time == 0)
|
|
{
|
|
/* This Sleep is controversial; it was added to make
|
|
Wine able to replicate a high speed (e.g. 1 ms)
|
|
timer event where the called event routine chews
|
|
a lot of CPU. This is required because of the
|
|
bias some Linux kernel versions have against threads that
|
|
chew a lot of the CPU; this Sleep(0) yields enough
|
|
in that spin case doesn't trigger the bias.
|
|
Further, it should do no harm, but an fyi. */
|
|
Sleep(0);
|
|
continue;
|
|
}
|
|
|
|
rc = WaitForSingleObject(TIME_hWakeEvent, sleep_time);
|
|
if (rc != WAIT_TIMEOUT && rc != WAIT_OBJECT_0)
|
|
{
|
|
FIXME("Unexpected error %ld(%ld) in timer thread\n", rc, GetLastError());
|
|
break;
|
|
}
|
|
}
|
|
TRACE("Exiting main winmm thread\n");
|
|
return 0;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* TIME_MMTimeStart
|
|
*/
|
|
void TIME_MMTimeStart(void)
|
|
{
|
|
if (!TIME_hMMTimer) {
|
|
TIME_TimersList = NULL;
|
|
TIME_hWakeEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
|
|
TIME_TimeToDie = FALSE;
|
|
TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, WINMM_IData, 0, NULL);
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* TIME_MMTimeStop
|
|
*/
|
|
void TIME_MMTimeStop(void)
|
|
{
|
|
if (TIME_hMMTimer) {
|
|
|
|
TIME_TimeToDie = TRUE;
|
|
SetEvent(TIME_hWakeEvent);
|
|
|
|
/* FIXME: in the worst case, we're going to wait 65 seconds here :-( */
|
|
WaitForSingleObject(TIME_hMMTimer, INFINITE);
|
|
|
|
CloseHandle(TIME_hMMTimer);
|
|
CloseHandle(TIME_hWakeEvent);
|
|
TIME_hMMTimer = 0;
|
|
TIME_TimersList = NULL;
|
|
}
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeGetSystemTime [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize)
|
|
{
|
|
|
|
if (wSize >= sizeof(*lpTime)) {
|
|
lpTime->wType = TIME_MS;
|
|
lpTime->u.ms = GetTickCount();
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* TIME_SetEventInternal [internal]
|
|
*/
|
|
WORD TIME_SetEventInternal(UINT wDelay, UINT wResol,
|
|
LPTIMECALLBACK lpFunc, DWORD dwUser, UINT wFlags)
|
|
{
|
|
WORD wNewID = 0;
|
|
LPWINE_TIMERENTRY lpNewTimer;
|
|
LPWINE_TIMERENTRY lpTimer;
|
|
|
|
TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
|
|
|
|
lpNewTimer = (LPWINE_TIMERENTRY)HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_TIMERENTRY));
|
|
if (lpNewTimer == NULL)
|
|
return 0;
|
|
|
|
if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
|
|
return 0;
|
|
|
|
TIME_MMTimeStart();
|
|
|
|
lpNewTimer->wDelay = wDelay;
|
|
lpNewTimer->dwTriggerTime = GetTickCount() + wDelay;
|
|
|
|
/* FIXME - wResol is not respected, although it is not clear
|
|
that we could change our precision meaningfully */
|
|
lpNewTimer->wResol = wResol;
|
|
lpNewTimer->lpFunc = lpFunc;
|
|
lpNewTimer->dwUser = dwUser;
|
|
lpNewTimer->wFlags = wFlags;
|
|
|
|
EnterCriticalSection(&WINMM_IData->cs);
|
|
|
|
if ((wFlags & TIME_KILL_SYNCHRONOUS) && !TIME_hKillEvent)
|
|
TIME_hKillEvent = CreateEventW(NULL, TRUE, TRUE, NULL);
|
|
|
|
for (lpTimer = TIME_TimersList; lpTimer != NULL; lpTimer = lpTimer->lpNext) {
|
|
wNewID = max(wNewID, lpTimer->wTimerID);
|
|
}
|
|
|
|
lpNewTimer->lpNext = TIME_TimersList;
|
|
TIME_TimersList = lpNewTimer;
|
|
lpNewTimer->wTimerID = wNewID + 1;
|
|
|
|
LeaveCriticalSection(&WINMM_IData->cs);
|
|
|
|
/* Wake the service thread in case there is work to be done */
|
|
SetEvent(TIME_hWakeEvent);
|
|
|
|
TRACE("=> %u\n", wNewID + 1);
|
|
|
|
return wNewID + 1;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeSetEvent [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
|
|
DWORD_PTR dwUser, UINT wFlags)
|
|
{
|
|
if (wFlags & WINE_TIMER_IS32)
|
|
WARN("Unknown windows flag... wine internally used.. ooch\n");
|
|
|
|
return TIME_SetEventInternal(wDelay, wResol, lpFunc,
|
|
dwUser, wFlags|WINE_TIMER_IS32);
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeKillEvent [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeKillEvent(UINT wID)
|
|
{
|
|
LPWINE_TIMERENTRY lpSelf = NULL, *lpTimer;
|
|
|
|
TRACE("(%u)\n", wID);
|
|
EnterCriticalSection(&WINMM_IData->cs);
|
|
/* remove WINE_TIMERENTRY from list */
|
|
for (lpTimer = &TIME_TimersList; *lpTimer; lpTimer = &(*lpTimer)->lpNext) {
|
|
if (wID == (*lpTimer)->wTimerID) {
|
|
lpSelf = *lpTimer;
|
|
/* unlink timer of id 'wID' */
|
|
*lpTimer = (*lpTimer)->lpNext;
|
|
break;
|
|
}
|
|
}
|
|
LeaveCriticalSection(&WINMM_IData->cs);
|
|
|
|
if (!lpSelf)
|
|
{
|
|
WARN("wID=%u is not a valid timer ID\n", wID);
|
|
return MMSYSERR_INVALPARAM;
|
|
}
|
|
if (lpSelf->wFlags & TIME_KILL_SYNCHRONOUS)
|
|
WaitForSingleObject(TIME_hKillEvent, INFINITE);
|
|
HeapFree(GetProcessHeap(), 0, lpSelf);
|
|
return TIMERR_NOERROR;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeGetDevCaps [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
|
|
{
|
|
TRACE("(%p, %u)\n", lpCaps, wSize);
|
|
|
|
lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
|
|
lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
|
|
return 0;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeBeginPeriod [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
|
|
{
|
|
if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
|
|
return TIMERR_NOCANDO;
|
|
|
|
if (wPeriod > MMSYSTIME_MININTERVAL)
|
|
{
|
|
FIXME("Stub; we set our timer resolution at minimum\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeEndPeriod [WINMM.@]
|
|
*/
|
|
MMRESULT WINAPI timeEndPeriod(UINT wPeriod)
|
|
{
|
|
if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
|
|
return TIMERR_NOCANDO;
|
|
|
|
if (wPeriod > MMSYSTIME_MININTERVAL)
|
|
{
|
|
FIXME("Stub; we set our timer resolution at minimum\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**************************************************************************
|
|
* timeGetTime [MMSYSTEM.607]
|
|
* timeGetTime [WINMM.@]
|
|
*/
|
|
DWORD WINAPI timeGetTime(void)
|
|
{
|
|
#if defined(COMMENTOUTPRIORTODELETING)
|
|
DWORD count;
|
|
|
|
/* FIXME: releasing the win16 lock here is a temporary hack (I hope)
|
|
* that lets mciavi.drv run correctly
|
|
*/
|
|
if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
|
|
if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
|
|
#endif
|
|
|
|
return GetTickCount();
|
|
}
|