time.c File Reference

#include "winemm.h"

Include dependency graph for time.c:

Go to the source code of this file.

Classes
struct	tagWINE_TIMERENTRY

Macros
#define	MMSYSTIME_MININTERVAL   (1)
#define	MMSYSTIME_MAXINTERVAL   (65535)

Typedefs
typedef struct tagWINE_TIMERENTRY	WINE_TIMERENTRY
typedef struct tagWINE_TIMERENTRY *	LPWINE_TIMERENTRY

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (mmtime)
static void	TIME_TriggerCallBack (LPWINE_TIMERENTRY lpTimer)
static DWORD CALLBACK	TIME_MMSysTimeCallback ()
static DWORD CALLBACK	TIME_MMSysTimeThread (LPVOID arg)
void	TIME_MMTimeStart (void)
void	TIME_MMTimeStop (void)
MMRESULT WINAPI	timeGetSystemTime (LPMMTIME lpTime, UINT wSize)
WORD	TIME_SetEventInternal (UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc, DWORD dwUser, UINT wFlags)
MMRESULT WINAPI	timeSetEvent (UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc, DWORD_PTR dwUser, UINT wFlags)
MMRESULT WINAPI	timeKillEvent (UINT wID)
MMRESULT WINAPI	timeGetDevCaps (LPTIMECAPS lpCaps, UINT wSize)
MMRESULT WINAPI	timeBeginPeriod (UINT wPeriod)
MMRESULT WINAPI	timeEndPeriod (UINT wPeriod)
DWORD WINAPI	timeGetTime (void)

Variables
static HANDLE	TIME_hMMTimer
static LPWINE_TIMERENTRY	TIME_TimersList
static HANDLE	TIME_hKillEvent
static HANDLE	TIME_hWakeEvent
static BOOL	TIME_TimeToDie = TRUE
static LARGE_INTEGER	TIME_qpcFreq

Macro Definition Documentation

MMSYSTIME_MAXINTERVAL

#define MMSYSTIME_MAXINTERVAL   (65535)

Definition at line 79 of file time.c.

MMSYSTIME_MININTERVAL

#define MMSYSTIME_MININTERVAL   (1)

Definition at line 78 of file time.c.

Typedef Documentation

LPWINE_TIMERENTRY

typedef struct tagWINE_TIMERENTRY * LPWINE_TIMERENTRY

WINE_TIMERENTRY

typedef struct tagWINE_TIMERENTRY WINE_TIMERENTRY

Function Documentation

TIME_MMSysTimeCallback()

static DWORD CALLBACK TIME_MMSysTimeCallback ( )

static

Definition at line 113 of file time.c.

{
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(&WINMM_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(&WINMM_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);
}

Referenced by TIME_MMSysTimeThread().

TIME_MMSysTimeThread()

static DWORD CALLBACK TIME_MMSysTimeThread ( LPVOID  arg )

static

Definition at line 223 of file time.c.

{
    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();
 
        if (sleep_time == 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;
}

Referenced by TIME_MMTimeStart().

TIME_MMTimeStart()

void TIME_MMTimeStart

(

void

)

Definition at line 257 of file time.c.

{
    if (!TIME_hMMTimer) {
    TIME_TimersList = NULL;
        TIME_hWakeEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
        TIME_TimeToDie = FALSE;
    TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, NULL, 0, NULL);
        SetThreadPriority(TIME_hMMTimer, THREAD_PRIORITY_TIME_CRITICAL);
    }
}

Referenced by TIME_SetEventInternal().

TIME_MMTimeStop()

void TIME_MMTimeStop

(

void

)

Definition at line 271 of file time.c.

{
    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;
    }
}

Referenced by WINMM_DeleteIData().

TIME_SetEventInternal()

WORD TIME_SetEventInternal	(	UINT	wDelay,
		UINT	wResol,
		LPTIMECALLBACK	lpFunc,
		DWORD	dwUser,
		UINT	wFlags
	)

Definition at line 306 of file time.c.

{
    WORD        wNewID = 0;
    LPWINE_TIMERENTRY   lpNewTimer;
    LPWINE_TIMERENTRY   lpTimer;
 
    TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
 
    if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
    return 0;
 
    lpNewTimer = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_TIMERENTRY));
    if (lpNewTimer == NULL)
    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_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_cs);
 
    /* Wake the service thread in case there is work to be done */
    SetEvent(TIME_hWakeEvent);
 
    TRACE("=> %u\n", wNewID + 1);
 
    return wNewID + 1;
}

Referenced by timeSetEvent().

TIME_TriggerCallBack()

static void TIME_TriggerCallBack ( LPWINE_TIMERENTRY  lpTimer )

static

Definition at line 82 of file time.c.

{
    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:
        (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;
    }
}

Referenced by TIME_MMSysTimeCallback().

timeBeginPeriod()

MMRESULT WINAPI timeBeginPeriod

(

UINT

wPeriod

)

Definition at line 423 of file time.c.

{
    if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
        return TIMERR_NOCANDO;
 
    /*  High resolution timer requested, use QPC */
    if (wPeriod <= 5 && TIME_qpcFreq.QuadPart == 0)
    {
        if (QueryPerformanceFrequency(&TIME_qpcFreq))
            TIME_qpcFreq.QuadPart /= 1000;
    }
 
    if (wPeriod > MMSYSTIME_MININTERVAL)
    {
        WARN("Stub; we set our timer resolution at minimum\n");
    }
 
    return 0;
}

Referenced by DirectSoundDevice_Initialize(), and test_timer().

timeEndPeriod()

MMRESULT WINAPI timeEndPeriod

(

UINT

wPeriod

)

Definition at line 446 of file time.c.

{
    if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
        return TIMERR_NOCANDO;
 
    /*  High resolution timer no longer requested, stop using QPC */
    if (wPeriod <= 5 && TIME_qpcFreq.QuadPart != 0)
        TIME_qpcFreq.QuadPart = 0;
 
    if (wPeriod > MMSYSTIME_MININTERVAL)
    {
        WARN("Stub; we set our timer resolution at minimum\n");
    }
    return 0;
}

Referenced by DirectSoundDevice_Release(), DSOUND_timer(), and test_timer().

timeGetDevCaps()

MMRESULT WINAPI timeGetDevCaps	(	LPTIMECAPS	lpCaps,
		UINT	wSize
	)

Definition at line 401 of file time.c.

{
    TRACE("(%p, %u)\n", lpCaps, wSize);
 
    if (lpCaps == 0) {
        WARN("invalid lpCaps\n");
        return TIMERR_NOCANDO;
    }
 
    if (wSize < sizeof(TIMECAPS)) {
        WARN("invalid wSize\n");
        return TIMERR_NOCANDO;
    }
 
    lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
    lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
    return TIMERR_NOERROR;
}

Referenced by DirectSoundDevice_Initialize(), and test_timeGetDevCaps().

timeGetSystemTime()

MMRESULT WINAPI timeGetSystemTime	(	LPMMTIME	lpTime,
		UINT	wSize
	)

Definition at line 291 of file time.c.

{
 
    if (wSize >= sizeof(*lpTime)) {
    lpTime->wType = TIME_MS;
    lpTime->u.ms = GetTickCount();
 
    }
 
    return 0;
}

timeGetTime()

DWORD WINAPI timeGetTime

(

void

)

Definition at line 466 of file time.c.

{
    LARGE_INTEGER perfCount;
#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
    /* Use QPC if a high-resolution timer was requested (<= 5ms) */
    if (TIME_qpcFreq.QuadPart != 0)
    {
        QueryPerformanceCounter(&perfCount);
        return (DWORD)(perfCount.QuadPart / TIME_qpcFreq.QuadPart);
    }
    /* Otherwise continue using GetTickCount */
    return GetTickCount();
}

Referenced by NS_AddRemoteComputerAsNameServer(), NS_PruneSessionCache(), and testTimeProc().

timeKillEvent()

MMRESULT WINAPI timeKillEvent

(

UINT

wID

)

Definition at line 370 of file time.c.

{
    LPWINE_TIMERENTRY   lpSelf = NULL, *lpTimer;
 
    TRACE("(%u)\n", wID);
    EnterCriticalSection(&WINMM_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_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;
}

Referenced by DirectSoundDevice_Release(), DSOUND_timer(), ScreenSaverProc(), test_priority(), and test_timer().

timeSetEvent()

MMRESULT WINAPI timeSetEvent	(	UINT	wDelay,
		UINT	wResol,
		LPTIMECALLBACK	lpFunc,
		DWORD_PTR	dwUser,
		UINT	wFlags
	)

Definition at line 360 of file time.c.

{
    return TIME_SetEventInternal(wDelay, wResol, lpFunc,
                                 dwUser, wFlags);
}

Referenced by DirectSoundDevice_Initialize(), ScreenSaverProc(), test_priority(), and test_timer().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

mmtime

)

Variable Documentation

TIME_hKillEvent

HANDLE TIME_hKillEvent

static

Definition at line 47 of file time.c.

Referenced by TIME_MMSysTimeCallback(), TIME_SetEventInternal(), and timeKillEvent().

TIME_hMMTimer

HANDLE TIME_hMMTimer

static

Definition at line 45 of file time.c.

Referenced by TIME_MMTimeStart(), and TIME_MMTimeStop().

TIME_hWakeEvent

HANDLE TIME_hWakeEvent

static

Definition at line 48 of file time.c.

Referenced by TIME_MMSysTimeThread(), TIME_MMTimeStart(), TIME_MMTimeStop(), and TIME_SetEventInternal().

TIME_qpcFreq

LARGE_INTEGER TIME_qpcFreq

static

Definition at line 50 of file time.c.

Referenced by timeBeginPeriod(), timeEndPeriod(), and timeGetTime().

TIME_TimersList

LPWINE_TIMERENTRY TIME_TimersList

static

Definition at line 46 of file time.c.

Referenced by TIME_MMSysTimeCallback(), TIME_MMTimeStart(), TIME_MMTimeStop(), TIME_SetEventInternal(), and timeKillEvent().

TIME_TimeToDie

BOOL TIME_TimeToDie = TRUE

static

Definition at line 49 of file time.c.

Referenced by TIME_MMSysTimeThread(), TIME_MMTimeStart(), and TIME_MMTimeStop().