ReceiveTempSMS/Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

- simplified internal data

Browse Source 
- thread safe access to internal structures
- fixed bug on ONE_SHOT timers
- deferred service thread call until really needed (no longer on WINMM
  or MMSYSTEM attachement)
This commit is contained in:
Eric Pouech 1999-06-12 08:25:36 +00:00 committed by Alexandre Julliard
parent 63c7cdf196
commit 0e35ebada0
1 changed files with 114 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

159
multimedia/time.c
View File

@ -7,23 +7,17 @@
*/ */
#include <stdlib.h> #include <stdlib.h>
#include <string.h>
#include <time.h> #include <time.h>
#include <sys/time.h> #include <sys/time.h>
#include "winbase.h" #include "winbase.h"
#include "wine/winbase16.h" /* GetTaskDS */ #include "wine/winbase16.h" /* GetTaskDS */
#include "callback.h" #include "callback.h"
#include "mmsystem.h" #include "mmsystem.h"
#include "xmalloc.h"
#include "services.h" #include "services.h"
#include "options.h"
#include "debugtools.h" #include "debugtools.h"
DEFAULT_DEBUG_CHANNEL(mmtime) DEFAULT_DEBUG_CHANNEL(mmtime)
static MMTIME16 mmSysTimeMS;
static MMTIME16 mmSysTimeSMPTE;
typedef struct tagTIMERENTRY { typedef struct tagTIMERENTRY {
UINT wDelay; UINT wDelay;
UINT wResol; UINT wResol;
@ -34,11 +28,13 @@ typedef struct tagTIMERENTRY {
UINT wTimerID; UINT wTimerID;
UINT wCurTime; UINT wCurTime;
UINT isWin32; UINT isWin32;
struct tagTIMERENTRY* Next; struct tagTIMERENTRY* lpNext;
} TIMERENTRY, *LPTIMERENTRY; } TIMERENTRY, *LPTIMERENTRY;
static DWORD mmSysTimeMS;
static LPTIMERENTRY lpTimerList = NULL; static LPTIMERENTRY lpTimerList = NULL;
static HANDLE hMMTimer; static HANDLE hMMTimer = 0;
CRITICAL_SECTION mmTimeCritSect;
/* /*
* FIXME * FIXME
@ -51,15 +47,12 @@ static HANDLE hMMTimer;
static void TIME_TriggerCallBack(LPTIMERENTRY lpTimer, DWORD dwCurrent) static void TIME_TriggerCallBack(LPTIMERENTRY lpTimer, DWORD dwCurrent)
{ {
lpTimer->wCurTime = lpTimer->wDelay;
if (lpTimer->lpFunc != (FARPROC16) NULL) { if (lpTimer->lpFunc != (FARPROC16) NULL) {
TRACE("before CallBack16 (%lu)!\n", dwCurrent); TRACE("before CallBack (%lu)!\n", dwCurrent);
TRACE("lpFunc=%p wTimerID=%04X dwUser=%08lX !\n", TRACE("lpFunc=%p wTimerID=%04X dwUser=%08lX !\n",
lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser); lpTimer->lpFunc, lpTimer->wTimerID, lpTimer->dwUser);
TRACE("hInstance=%04X !\n", lpTimer->hInstance); TRACE("hInstance=%04X !\n", lpTimer->hInstance);
/* - TimeProc callback that is called here is something strange, under Windows 3.1x it is called /* - 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 * 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 * PostMessage), and must reside in DLL (therefore uses stack of active application). So I
@ -68,7 +61,7 @@ static void TIME_TriggerCallBack(LPTIMERENTRY lpTimer, DWORD dwCurrent)
switch (lpTimer->wFlags & 0x30) { switch (lpTimer->wFlags & 0x30) {
case TIME_CALLBACK_FUNCTION: case TIME_CALLBACK_FUNCTION:
if (lpTimer->isWin32) if (lpTimer->isWin32)
lpTimer->lpFunc(lpTimer->wTimerID, 0, lpTimer->dwUser, 0, 0); ((LPTIMECALLBACK)lpTimer->lpFunc)(lpTimer->wTimerID, 0, lpTimer->dwUser, 0, 0);
else else
Callbacks->CallTimeFuncProc(lpTimer->lpFunc, Callbacks->CallTimeFuncProc(lpTimer->lpFunc,
lpTimer->wTimerID, 0, lpTimer->wTimerID, 0,
@ -84,29 +77,35 @@ static void TIME_TriggerCallBack(LPTIMERENTRY lpTimer, DWORD dwCurrent)
FIXME("Unknown callback type 0x%04x for mmtime callback (%p), ignored.\n", lpTimer->wFlags, lpTimer->lpFunc); FIXME("Unknown callback type 0x%04x for mmtime callback (%p), ignored.\n", lpTimer->wFlags, lpTimer->lpFunc);
break; break;
} }
TRACE("after CallBack16 !\n"); TRACE("after CallBack !\n");
} }
if (lpTimer->wFlags & TIME_ONESHOT)
timeKillEvent(lpTimer->wTimerID);
} }
/************************************************************************** /**************************************************************************
* TIME_MMSysTimeCallback * TIME_MMSysTimeCallback
*/ */
static VOID CALLBACK TIME_MMSysTimeCallback( ULONG_PTR dummy ) static void CALLBACK TIME_MMSysTimeCallback( ULONG_PTR dummy )
{ {
LPTIMERENTRY lpTimer; LPTIMERENTRY lpTimer, lpNextTimer;
mmSysTimeMS.u.ms += MMSYSTIME_MININTERVAL; mmSysTimeMS += MMSYSTIME_MININTERVAL;
mmSysTimeSMPTE.u.smpte.frame++;
for (lpTimer = lpTimerList; lpTimer != NULL; lpTimer = lpTimer->Next) { EnterCriticalSection(&mmTimeCritSect);
for (lpTimer = lpTimerList; lpTimer != NULL; ) {
lpNextTimer = lpTimer->lpNext;
if (lpTimer->wCurTime < MMSYSTIME_MININTERVAL) { if (lpTimer->wCurTime < MMSYSTIME_MININTERVAL) {
TIME_TriggerCallBack(lpTimer, mmSysTimeMS.u.ms); lpTimer->wCurTime = lpTimer->wDelay;
TIME_TriggerCallBack(lpTimer, mmSysTimeMS);
if (lpTimer->wFlags & TIME_ONESHOT)
timeKillEvent(lpTimer->wTimerID);
} else { } else {
lpTimer->wCurTime -= MMSYSTIME_MININTERVAL; lpTimer->wCurTime -= MMSYSTIME_MININTERVAL;
} }
lpTimer = lpNextTimer;
} }
LeaveCriticalSection(&mmTimeCritSect);
} }
/************************************************************************** /**************************************************************************
@ -114,16 +113,25 @@ static VOID CALLBACK TIME_MMSysTimeCallback( ULONG_PTR dummy )
*/ */
BOOL MULTIMEDIA_MMTimeInit(void) BOOL MULTIMEDIA_MMTimeInit(void)
{ {
mmSysTimeMS.wType = TIME_MS; InitializeCriticalSection(&mmTimeCritSect);
mmSysTimeMS.u.ms = GetTickCount(); MakeCriticalSectionGlobal(&mmTimeCritSect);
mmSysTimeSMPTE.wType = TIME_SMPTE;
mmSysTimeSMPTE.u.smpte.hour = 0; return TRUE;
mmSysTimeSMPTE.u.smpte.min = 0; }
mmSysTimeSMPTE.u.smpte.sec = 0;
mmSysTimeSMPTE.u.smpte.frame = 0; /**************************************************************************
mmSysTimeSMPTE.u.smpte.fps = 0; * MULTIMEDIA_MMTimeStart [internal]
mmSysTimeSMPTE.u.smpte.dummy = 0; */
static BOOL MULTIMEDIA_MMTimeStart(void)
{
/* one could think it's possible to stop the service thread activity when no more
* mm timers are active, but this would require to handle delta (in time) between
* GetTickCount() and timeGetTime() which are not -currently- synchronized.
*/
if (!hMMTimer) {
mmSysTimeMS = GetTickCount();
hMMTimer = SERVICE_AddTimer( MMSYSTIME_MININTERVAL*1000L, TIME_MMSysTimeCallback, 0 ); hMMTimer = SERVICE_AddTimer( MMSYSTIME_MININTERVAL*1000L, TIME_MMSysTimeCallback, 0 );
}
return TRUE; return TRUE;
} }
@ -135,10 +143,13 @@ MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize)
{ {
TRACE("(%p, %u);\n", lpTime, wSize); TRACE("(%p, %u);\n", lpTime, wSize);
if (wSize >= sizeof(*lpTime)) {
MULTIMEDIA_MMTimeStart();
lpTime->wType = TIME_MS; lpTime->wType = TIME_MS;
lpTime->u.ms = mmSysTimeMS.u.ms; lpTime->u.ms = mmSysTimeMS;
TRACE("=> %lu\n", mmSysTimeMS.u.ms); TRACE("=> %lu\n", mmSysTimeMS);
}
return 0; return 0;
} }
@ -150,10 +161,13 @@ MMRESULT16 WINAPI timeGetSystemTime16(LPMMTIME16 lpTime, UINT16 wSize)
{ {
TRACE("(%p, %u);\n", lpTime, wSize); TRACE("(%p, %u);\n", lpTime, wSize);
if (wSize >= sizeof(*lpTime)) {
MULTIMEDIA_MMTimeStart();
lpTime->wType = TIME_MS; lpTime->wType = TIME_MS;
lpTime->u.ms = mmSysTimeMS.u.ms; lpTime->u.ms = mmSysTimeMS;
TRACE("=> %lu\n", mmSysTimeMS.u.ms); TRACE("=> %lu\n", mmSysTimeMS);
}
return 0; return 0;
} }
@ -167,55 +181,58 @@ static WORD timeSetEventInternal(UINT wDelay, UINT wResol,
{ {
WORD wNewID = 0; WORD wNewID = 0;
LPTIMERENTRY lpNewTimer; LPTIMERENTRY lpNewTimer;
LPTIMERENTRY lpTimer = lpTimerList; LPTIMERENTRY lpTimer;
TRACE("(%u, %u, %p, %08lX, %04X);\n", TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
wDelay, wResol, lpFunc, dwUser, wFlags);
lpNewTimer = (LPTIMERENTRY)xmalloc(sizeof(TIMERENTRY)); lpNewTimer = (LPTIMERENTRY)malloc(sizeof(TIMERENTRY));
if (lpNewTimer == NULL) if (lpNewTimer == NULL)
return 0; return 0;
while (lpTimer != NULL) {
wNewID = MAX(wNewID, lpTimer->wTimerID);
lpTimer = lpTimer->Next;
}
lpNewTimer->Next = lpTimerList; MULTIMEDIA_MMTimeStart();
lpTimerList = lpNewTimer;
lpNewTimer->wTimerID = wNewID + 1;
lpNewTimer->wCurTime = wDelay; lpNewTimer->wCurTime = wDelay;
lpNewTimer->wDelay = wDelay; lpNewTimer->wDelay = wDelay;
lpNewTimer->wResol = wResol; lpNewTimer->wResol = wResol;
lpNewTimer->lpFunc = lpFunc; lpNewTimer->lpFunc = lpFunc;
lpNewTimer->isWin32 = isWin32; lpNewTimer->isWin32 = isWin32;
lpNewTimer->hInstance = GetTaskDS16(); lpNewTimer->hInstance = GetTaskDS16();
TRACE("hInstance=%04X !\n", lpNewTimer->hInstance);
TRACE("lpFunc=0x%08lx !\n", (DWORD)lpFunc );
lpNewTimer->dwUser = dwUser; lpNewTimer->dwUser = dwUser;
lpNewTimer->wFlags = wFlags; lpNewTimer->wFlags = wFlags;
return lpNewTimer->wTimerID;
TRACE("hInstance=%04X,lpFunc=0x%08lx !\n", lpNewTimer->hInstance, (DWORD)lpFunc);
EnterCriticalSection(&mmTimeCritSect);
for (lpTimer = lpTimerList; lpTimer != NULL; lpTimer = lpTimer->lpNext) {
wNewID = MAX(wNewID, lpTimer->wTimerID);
}
lpNewTimer->lpNext = lpTimerList;
lpTimerList = lpNewTimer;
lpNewTimer->wTimerID = wNewID + 1;
LeaveCriticalSection(&mmTimeCritSect);
return wNewID + 1;
} }
/************************************************************************** /**************************************************************************
* timeSetEvent [MMSYSTEM.602] * timeSetEvent [MMSYSTEM.602]
*/ */
MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
LPTIMECALLBACK lpFunc, DWORD dwUser, DWORD dwUser, UINT wFlags)
UINT wFlags)
{ {
return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc, return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc, dwUser, wFlags, 1);
dwUser, wFlags, 1);
} }
/************************************************************************** /**************************************************************************
* timeSetEvent [MMSYSTEM.602] * timeSetEvent [MMSYSTEM.602]
*/ */
MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol, LPTIMECALLBACK16 lpFunc,
LPTIMECALLBACK16 lpFunc, DWORD dwUser, DWORD dwUser, UINT16 wFlags)
UINT16 wFlags)
{ {
return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc, return timeSetEventInternal(wDelay, wResol, (FARPROC16)lpFunc, dwUser, wFlags, 0);
dwUser, wFlags, 0);
} }
/************************************************************************** /**************************************************************************
@ -224,17 +241,24 @@ MMRESULT16 WINAPI timeSetEvent16(UINT16 wDelay, UINT16 wResol,
MMRESULT WINAPI timeKillEvent(UINT wID) MMRESULT WINAPI timeKillEvent(UINT wID)
{ {
LPTIMERENTRY* lpTimer; LPTIMERENTRY* lpTimer;
MMRESULT ret = MMSYSERR_INVALPARAM;
for (lpTimer = &lpTimerList; *lpTimer; lpTimer = &((*lpTimer)->Next)) { EnterCriticalSection(&mmTimeCritSect);
for (lpTimer = &lpTimerList; *lpTimer; lpTimer = &((*lpTimer)->lpNext)) {
if (wID == (*lpTimer)->wTimerID) { if (wID == (*lpTimer)->wTimerID) {
LPTIMERENTRY xlptimer = (*lpTimer)->Next; LPTIMERENTRY xlptimer = (*lpTimer)->lpNext;
free(*lpTimer); free(*lpTimer);
*lpTimer = xlptimer; *lpTimer = xlptimer;
return TRUE; ret = TIMERR_NOERROR;
break;
} }
} }
return 0;
LeaveCriticalSection(&mmTimeCritSect);
return ret;
} }
/************************************************************************** /**************************************************************************
@ -280,8 +304,9 @@ MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
return TIMERR_NOCANDO; return TIMERR_NOCANDO;
return 0; return 0;
} }
/************************************************************************** /**************************************************************************
* timeBeginPeriod [MMSYSTEM.605] * timeBeginPeriod16 [MMSYSTEM.605]
*/ */
MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod) MMRESULT16 WINAPI timeBeginPeriod16(UINT16 wPeriod)
{ {
@ -305,11 +330,12 @@ MMRESULT WINAPI timeEndPeriod(UINT wPeriod)
} }
/************************************************************************** /**************************************************************************
* timeEndPeriod [MMSYSTEM.606] * timeEndPeriod16 [MMSYSTEM.606]
*/ */
MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod) MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
{ {
TRACE("(%u) !\n", wPeriod); TRACE("(%u) !\n", wPeriod);
if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL) if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
return TIMERR_NOCANDO; return TIMERR_NOCANDO;
return 0; return 0;
@ -320,5 +346,6 @@ MMRESULT16 WINAPI timeEndPeriod16(UINT16 wPeriod)
*/ */
DWORD WINAPI timeGetTime(void) DWORD WINAPI timeGetTime(void)
{ {
return mmSysTimeMS.u.ms; MULTIMEDIA_MMTimeStart();
return mmSysTimeMS;
} }