1 /* -*- tab-width: 8; c-basic-offset: 4 -*- */
2
3 /*
4 * MMSYSTEM time functions
5 *
6 * Copyright 1993 Martin Ayotte
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <errno.h>
28 #include <time.h>
29 #ifdef HAVE_SYS_TIME_H
30 # include <sys/time.h>
31 #endif
32 #ifdef HAVE_UNISTD_H
33 # include <unistd.h>
34 #endif
35 #ifdef HAVE_POLL_H
36 #include <poll.h>
37 #endif
38 #ifdef HAVE_SYS_POLL_H
39 #include <sys/poll.h>
40 #endif
41
42 #include "windef.h"
43 #include "winbase.h"
44 #include "mmsystem.h"
45
46 #include "winemm.h"
47
48 #include "wine/list.h"
49 #include "wine/debug.h"
50
51 WINE_DEFAULT_DEBUG_CHANNEL(mmtime);
52
53 typedef struct tagWINE_TIMERENTRY {
54 struct list entry;
55 UINT wDelay;
56 UINT wResol;
57 LPTIMECALLBACK lpFunc; /* can be lots of things */
58 DWORD_PTR dwUser;
59 UINT16 wFlags;
60 UINT16 wTimerID;
61 DWORD dwTriggerTime;
62 } WINE_TIMERENTRY, *LPWINE_TIMERENTRY;
63
64 static struct list timer_list = LIST_INIT(timer_list);
65
66 static CRITICAL_SECTION TIME_cbcrst;
67 static CRITICAL_SECTION_DEBUG critsect_debug =
68 {
69 0, 0, &TIME_cbcrst,
70 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
71 0, 0, { (DWORD_PTR)(__FILE__ ": TIME_cbcrst") }
72 };
73 static CRITICAL_SECTION TIME_cbcrst = { &critsect_debug, -1, 0, 0, 0, 0 };
74
75 static HANDLE TIME_hMMTimer;
76 static BOOL TIME_TimeToDie = TRUE;
77 static int TIME_fdWake[2] = { -1, -1 };
78
79 /* link timer at the appropriate spot in the list */
80 static inline void link_timer( WINE_TIMERENTRY *timer )
81 {
82 WINE_TIMERENTRY *next;
83
84 LIST_FOR_EACH_ENTRY( next, &timer_list, WINE_TIMERENTRY, entry )
85 if ((int)(next->dwTriggerTime - timer->dwTriggerTime) >= 0) break;
86
87 list_add_before( &next->entry, &timer->entry );
88 }
89
90 /*
91 * Some observations on the behavior of winmm on Windows.
92 * First, the call to timeBeginPeriod(xx) can never be used
93 * to raise the timer resolution, only lower it.
94 *
95 * Second, a brief survey of a variety of Win 2k and Win X
96 * machines showed that a 'standard' (aka default) timer
97 * resolution was 1 ms (Win9x is documented as being 1). However, one
98 * machine had a standard timer resolution of 10 ms.
99 *
100 * Further, if we set our default resolution to 1,
101 * the implementation of timeGetTime becomes GetTickCount(),
102 * and we can optimize the code to reduce overhead.
103 *
104 * Additionally, a survey of Event behaviors shows that
105 * if we request a Periodic event every 50 ms, then Windows
106 * makes sure to trigger that event 20 times in the next
107 * second. If delays prevent that from happening on exact
108 * schedule, Windows will trigger the events as close
109 * to the original schedule as is possible, and will eventually
110 * bring the event triggers back onto a schedule that is
111 * consistent with what would have happened if there were
112 * no delays.
113 *
114 * Jeremy White, October 2004
115 */
116 #define MMSYSTIME_MININTERVAL (1)
117 #define MMSYSTIME_MAXINTERVAL (65535)
118
119 #ifdef HAVE_POLL
120
121 /**************************************************************************
122 * TIME_MMSysTimeCallback
123 */
124 static int TIME_MMSysTimeCallback(void)
125 {
126 WINE_TIMERENTRY *timer, *to_free;
127 int delta_time;
128
129 /* since timeSetEvent() and timeKillEvent() can be called
130 * from 16 bit code, there are cases where win16 lock is
131 * locked upon entering timeSetEvent(), and then the mm timer
132 * critical section is locked. This function cannot call the
133 * timer callback with the crit sect locked (because callback
134 * may need to acquire Win16 lock, thus providing a deadlock
135 * situation).
136 * To cope with that, we just copy the WINE_TIMERENTRY struct
137 * that need to trigger the callback, and call it without the
138 * mm timer crit sect locked.
139 */
140
141 EnterCriticalSection(&WINMM_cs);
142 for (;;)
143 {
144 struct list *ptr = list_head( &timer_list );
145 if (!ptr)
146 {
147 delta_time = -1;
148 break;
149 }
150
151 timer = LIST_ENTRY( ptr, WINE_TIMERENTRY, entry );
152 delta_time = timer->dwTriggerTime - GetTickCount();
153 if (delta_time > 0) break;
154
155 list_remove( &timer->entry );
156 if (timer->wFlags & TIME_PERIODIC)
157 {
158 timer->dwTriggerTime += timer->wDelay;
159 link_timer( timer ); /* restart it */
160 to_free = NULL;
161 }
162 else to_free = timer;
163
164 switch(timer->wFlags & (TIME_CALLBACK_EVENT_SET|TIME_CALLBACK_EVENT_PULSE))
165 {
166 case TIME_CALLBACK_EVENT_SET:
167 SetEvent(timer->lpFunc);
168 break;
169 case TIME_CALLBACK_EVENT_PULSE:
170 PulseEvent(timer->lpFunc);
171 break;
172 case TIME_CALLBACK_FUNCTION:
173 {
174 DWORD_PTR user = timer->dwUser;
175 UINT16 id = timer->wTimerID;
176 UINT16 flags = timer->wFlags;
177 LPTIMECALLBACK func = timer->lpFunc;
178
179 if (flags & TIME_KILL_SYNCHRONOUS) EnterCriticalSection(&TIME_cbcrst);
180 LeaveCriticalSection(&WINMM_cs);
181
182 func(id, 0, user, 0, 0);
183
184 EnterCriticalSection(&WINMM_cs);
185 if (flags & TIME_KILL_SYNCHRONOUS) LeaveCriticalSection(&TIME_cbcrst);
186 }
187 break;
188 }
189 HeapFree( GetProcessHeap(), 0, to_free );
190 }
191 LeaveCriticalSection(&WINMM_cs);
192 return delta_time;
193 }
194
195 /**************************************************************************
196 * TIME_MMSysTimeThread
197 */
198 static DWORD CALLBACK TIME_MMSysTimeThread(LPVOID arg)
199 {
200 int sleep_time, ret;
201 char readme[16];
202 struct pollfd pfd;
203
204 pfd.fd = TIME_fdWake[0];
205 pfd.events = POLLIN;
206
207 TRACE("Starting main winmm thread\n");
208
209 /* FIXME: As an optimization, we could have
210 this thread die when there are no more requests
211 pending, and then get recreated on the first
212 new event; it's not clear if that would be worth
213 it or not. */
214
215 while (! TIME_TimeToDie)
216 {
217 sleep_time = TIME_MMSysTimeCallback();
218
219 if (sleep_time == 0)
220 continue;
221
222 if ((ret = poll(&pfd, 1, sleep_time)) < 0)
223 {
224 if (errno != EINTR && errno != EAGAIN)
225 {
226 ERR("Unexpected error in poll: %s(%d)\n", strerror(errno), errno);
227 break;
228 }
229 }
230
231 while (ret > 0) ret = read(TIME_fdWake[0], readme, sizeof(readme));
232 }
233 TRACE("Exiting main winmm thread\n");
234 return 0;
235 }
236
237 /**************************************************************************
238 * TIME_MMTimeStart
239 */
240 static void TIME_MMTimeStart(void)
241 {
242 if (!TIME_hMMTimer) {
243 if (pipe(TIME_fdWake) < 0)
244 {
245 TIME_fdWake[0] = TIME_fdWake[1] = -1;
246 ERR("Cannot create pipe: %s\n", strerror(errno));
247 } else {
248 fcntl(TIME_fdWake[0], F_SETFL, O_NONBLOCK);
249 fcntl(TIME_fdWake[1], F_SETFL, O_NONBLOCK);
250 }
251 TIME_TimeToDie = FALSE;
252 TIME_hMMTimer = CreateThread(NULL, 0, TIME_MMSysTimeThread, NULL, 0, NULL);
253 SetThreadPriority(TIME_hMMTimer, THREAD_PRIORITY_TIME_CRITICAL);
254 }
255 }
256
257 #else /* HAVE_POLL */
258
259 static void TIME_MMTimeStart(void)
260 {
261 FIXME( "not starting system thread\n" );
262 }
263
264 #endif /* HAVE_POLL */
265
266 /**************************************************************************
267 * TIME_MMTimeStop
268 */
269 void TIME_MMTimeStop(void)
270 {
271 if (TIME_hMMTimer) {
272 const char a='a';
273
274 TIME_TimeToDie = TRUE;
275 write(TIME_fdWake[1], &a, sizeof(a));
276
277 WaitForSingleObject(TIME_hMMTimer, INFINITE);
278 close(TIME_fdWake[0]);
279 close(TIME_fdWake[1]);
280 TIME_fdWake[0] = TIME_fdWake[1] = -1;
281 CloseHandle(TIME_hMMTimer);
282 TIME_hMMTimer = 0;
283 DeleteCriticalSection(&TIME_cbcrst);
284 }
285 }
286
287 /**************************************************************************
288 * timeGetSystemTime [WINMM.@]
289 */
290 MMRESULT WINAPI timeGetSystemTime(LPMMTIME lpTime, UINT wSize)
291 {
292
293 if (wSize >= sizeof(*lpTime)) {
294 lpTime->wType = TIME_MS;
295 lpTime->u.ms = GetTickCount();
296
297 }
298
299 return 0;
300 }
301
302 /**************************************************************************
303 * timeSetEvent [WINMM.@]
304 */
305 MMRESULT WINAPI timeSetEvent(UINT wDelay, UINT wResol, LPTIMECALLBACK lpFunc,
306 DWORD_PTR dwUser, UINT wFlags)
307 {
308 WORD wNewID = 0;
309 LPWINE_TIMERENTRY lpNewTimer;
310 LPWINE_TIMERENTRY lpTimer;
311 const char c = 'c';
312
313 TRACE("(%u, %u, %p, %08lX, %04X);\n", wDelay, wResol, lpFunc, dwUser, wFlags);
314
315 if (wDelay < MMSYSTIME_MININTERVAL || wDelay > MMSYSTIME_MAXINTERVAL)
316 return 0;
317
318 lpNewTimer = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_TIMERENTRY));
319 if (lpNewTimer == NULL)
320 return 0;
321
322 lpNewTimer->wDelay = wDelay;
323 lpNewTimer->dwTriggerTime = GetTickCount() + wDelay;
324
325 /* FIXME - wResol is not respected, although it is not clear
326 that we could change our precision meaningfully */
327 lpNewTimer->wResol = wResol;
328 lpNewTimer->lpFunc = lpFunc;
329 lpNewTimer->dwUser = dwUser;
330 lpNewTimer->wFlags = wFlags;
331
332 EnterCriticalSection(&WINMM_cs);
333
334 LIST_FOR_EACH_ENTRY( lpTimer, &timer_list, WINE_TIMERENTRY, entry )
335 wNewID = max(wNewID, lpTimer->wTimerID);
336
337 link_timer( lpNewTimer );
338 lpNewTimer->wTimerID = wNewID + 1;
339
340 TIME_MMTimeStart();
341
342 LeaveCriticalSection(&WINMM_cs);
343
344 /* Wake the service thread in case there is work to be done */
345 write(TIME_fdWake[1], &c, sizeof(c));
346
347 TRACE("=> %u\n", wNewID + 1);
348
349 return wNewID + 1;
350 }
351
352 /**************************************************************************
353 * timeKillEvent [WINMM.@]
354 */
355 MMRESULT WINAPI timeKillEvent(UINT wID)
356 {
357 WINE_TIMERENTRY *lpSelf = NULL, *lpTimer;
358 DWORD wFlags;
359
360 TRACE("(%u)\n", wID);
361 EnterCriticalSection(&WINMM_cs);
362 /* remove WINE_TIMERENTRY from list */
363 LIST_FOR_EACH_ENTRY( lpTimer, &timer_list, WINE_TIMERENTRY, entry )
364 {
365 if (wID == lpTimer->wTimerID) {
366 lpSelf = lpTimer;
367 list_remove( &lpTimer->entry );
368 break;
369 }
370 }
371 LeaveCriticalSection(&WINMM_cs);
372
373 if (!lpSelf)
374 {
375 WARN("wID=%u is not a valid timer ID\n", wID);
376 return MMSYSERR_INVALPARAM;
377 }
378 wFlags = lpSelf->wFlags;
379 if (wFlags & TIME_KILL_SYNCHRONOUS)
380 EnterCriticalSection(&TIME_cbcrst);
381 HeapFree(GetProcessHeap(), 0, lpSelf);
382 if (wFlags & TIME_KILL_SYNCHRONOUS)
383 LeaveCriticalSection(&TIME_cbcrst);
384 return TIMERR_NOERROR;
385 }
386
387 /**************************************************************************
388 * timeGetDevCaps [WINMM.@]
389 */
390 MMRESULT WINAPI timeGetDevCaps(LPTIMECAPS lpCaps, UINT wSize)
391 {
392 TRACE("(%p, %u)\n", lpCaps, wSize);
393
394 if (lpCaps == 0) {
395 WARN("invalid lpCaps\n");
396 return TIMERR_NOCANDO;
397 }
398
399 if (wSize < sizeof(TIMECAPS)) {
400 WARN("invalid wSize\n");
401 return TIMERR_NOCANDO;
402 }
403
404 lpCaps->wPeriodMin = MMSYSTIME_MININTERVAL;
405 lpCaps->wPeriodMax = MMSYSTIME_MAXINTERVAL;
406 return TIMERR_NOERROR;
407 }
408
409 /**************************************************************************
410 * timeBeginPeriod [WINMM.@]
411 */
412 MMRESULT WINAPI timeBeginPeriod(UINT wPeriod)
413 {
414 if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
415 return TIMERR_NOCANDO;
416
417 if (wPeriod > MMSYSTIME_MININTERVAL)
418 {
419 WARN("Stub; we set our timer resolution at minimum\n");
420 }
421
422 return 0;
423 }
424
425 /**************************************************************************
426 * timeEndPeriod [WINMM.@]
427 */
428 MMRESULT WINAPI timeEndPeriod(UINT wPeriod)
429 {
430 if (wPeriod < MMSYSTIME_MININTERVAL || wPeriod > MMSYSTIME_MAXINTERVAL)
431 return TIMERR_NOCANDO;
432
433 if (wPeriod > MMSYSTIME_MININTERVAL)
434 {
435 WARN("Stub; we set our timer resolution at minimum\n");
436 }
437 return 0;
438 }
439
440 /**************************************************************************
441 * timeGetTime [WINMM.@]
442 */
443 DWORD WINAPI timeGetTime(void)
444 {
445 #if defined(COMMENTOUTPRIORTODELETING)
446 DWORD count;
447
448 /* FIXME: releasing the win16 lock here is a temporary hack (I hope)
449 * that lets mciavi32.dll run correctly
450 */
451 if (pFnReleaseThunkLock) pFnReleaseThunkLock(&count);
452 if (pFnRestoreThunkLock) pFnRestoreThunkLock(count);
453 #endif
454
455 return GetTickCount();
456 }
457
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.