~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Wine Cross Reference
wine/dlls/winmm/time.c

Version: ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.