Implement thread semaphores
[vlc.git] / src / misc / w32thread.c
1 /*****************************************************************************
2  * w32thread.c : Win32 back-end for LibVLC
3  *****************************************************************************
4  * Copyright (C) 1999-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Gildas Bazin <gbazin@netcourrier.com>
10  *          Clément Sténac
11  *          Rémi Denis-Courmont
12  *          Pierre Ynard
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License as published by
16  * the Free Software Foundation; either version 2 of the License, or
17  * (at your option) any later version.
18  *
19  * This program is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
27  *****************************************************************************/
28
29 #ifdef HAVE_CONFIG_H
30 # include "config.h"
31 #endif
32
33 #include <vlc_common.h>
34
35 #include "libvlc.h"
36 #include <stdarg.h>
37 #include <assert.h>
38 #include <limits.h>
39 #ifdef UNDER_CE
40 # include <mmsystem.h>
41 #endif
42
43 static vlc_threadvar_t cancel_key;
44
45 /**
46  * Per-thread cancellation data
47  */
48 typedef struct vlc_cancel_t
49 {
50     vlc_cleanup_t *cleaners;
51 #ifdef UNDER_CE
52     HANDLE         cancel_event;
53 #endif
54     bool           killable;
55     bool           killed;
56 } vlc_cancel_t;
57
58 #ifndef UNDER_CE
59 # define VLC_CANCEL_INIT { NULL, true, false }
60 #else
61 # define VLC_CANCEL_INIT { NULL, NULL, true, false }
62 #endif
63
64 #ifdef UNDER_CE
65 static void CALLBACK vlc_cancel_self (ULONG_PTR dummy);
66
67 static DWORD vlc_cancelable_wait (DWORD count, const HANDLE *handles,
68                                   DWORD delay)
69 {
70     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
71     if (nfo == NULL)
72     {
73         /* Main thread - cannot be cancelled anyway */
74         return WaitForMultipleObjects (count, handles, FALSE, delay);
75     }
76     HANDLE new_handles[count + 1];
77     memcpy(new_handles, handles, count * sizeof(HANDLE));
78     new_handles[count] = nfo->cancel_event;
79     DWORD result = WaitForMultipleObjects (count + 1, new_handles, FALSE,
80                                            delay);
81     if (result == WAIT_OBJECT_0 + count)
82     {
83         vlc_cancel_self (NULL);
84         return WAIT_IO_COMPLETION;
85     }
86     else
87     {
88         return result;
89     }
90 }
91
92 DWORD SleepEx (DWORD dwMilliseconds, BOOL bAlertable)
93 {
94     if (bAlertable)
95     {
96         DWORD result = vlc_cancelable_wait (0, NULL, dwMilliseconds);
97         return (result == WAIT_TIMEOUT) ? 0 : WAIT_IO_COMPLETION;
98     }
99     else
100     {
101         Sleep(dwMilliseconds);
102         return 0;
103     }
104 }
105
106 DWORD WaitForSingleObjectEx (HANDLE hHandle, DWORD dwMilliseconds,
107                              BOOL bAlertable)
108 {
109     if (bAlertable)
110     {
111         /* The MSDN documentation specifies different return codes,
112          * but in practice they are the same. We just check that it
113          * remains so. */
114 #if WAIT_ABANDONED != WAIT_ABANDONED_0
115 # error Windows headers changed, code needs to be rewritten!
116 #endif
117         return vlc_cancelable_wait (1, &hHandle, dwMilliseconds);
118     }
119     else
120     {
121         return WaitForSingleObject (hHandle, dwMilliseconds);
122     }
123 }
124
125 DWORD WaitForMultipleObjectsEx (DWORD nCount, const HANDLE *lpHandles,
126                                 BOOL bWaitAll, DWORD dwMilliseconds,
127                                 BOOL bAlertable)
128 {
129     if (bAlertable)
130     {
131         /* We do not support the bWaitAll case */
132         assert (! bWaitAll);
133         return vlc_cancelable_wait (nCount, lpHandles, dwMilliseconds);
134     }
135     else
136     {
137         return WaitForMultipleObjects (nCount, lpHandles, bWaitAll,
138                                        dwMilliseconds);
139     }
140 }
141 #endif
142
143 static vlc_mutex_t super_mutex;
144
145 BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
146 {
147     (void) hinstDll;
148     (void) lpvReserved;
149
150     switch (fdwReason)
151     {
152         case DLL_PROCESS_ATTACH:
153             vlc_mutex_init (&super_mutex);
154             vlc_threadvar_create (&cancel_key, free);
155             break;
156
157         case DLL_PROCESS_DETACH:
158             vlc_threadvar_delete( &cancel_key );
159             vlc_mutex_destroy (&super_mutex);
160             break;
161     }
162     return TRUE;
163 }
164
165 /*** Mutexes ***/
166 void vlc_mutex_init( vlc_mutex_t *p_mutex )
167 {
168     /* This creates a recursive mutex. This is OK as fast mutexes have
169      * no defined behavior in case of recursive locking. */
170     InitializeCriticalSection (&p_mutex->mutex);
171     p_mutex->initialized = 1;
172 }
173
174 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
175 {
176     InitializeCriticalSection( &p_mutex->mutex );
177     p_mutex->initialized = 1;
178 }
179
180
181 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
182 {
183     assert (InterlockedExchange (&p_mutex->initialized, -1) == 1);
184     DeleteCriticalSection (&p_mutex->mutex);
185 }
186
187 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
188 {
189     if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
190     { /* ^^ We could also lock super_mutex all the time... sluggish */
191         assert (p_mutex != &super_mutex); /* this one cannot be static */
192
193         vlc_mutex_lock (&super_mutex);
194         if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
195             vlc_mutex_init (p_mutex);
196         /* FIXME: destroy the mutex some time... */
197         vlc_mutex_unlock (&super_mutex);
198     }
199     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
200     EnterCriticalSection (&p_mutex->mutex);
201 }
202
203 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
204 {
205     if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
206     { /* ^^ We could also lock super_mutex all the time... sluggish */
207         assert (p_mutex != &super_mutex); /* this one cannot be static */
208
209         vlc_mutex_lock (&super_mutex);
210         if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
211             vlc_mutex_init (p_mutex);
212         /* FIXME: destroy the mutex some time... */
213         vlc_mutex_unlock (&super_mutex);
214     }
215     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
216     return TryEnterCriticalSection (&p_mutex->mutex) ? 0 : EBUSY;
217 }
218
219 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
220 {
221     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
222     LeaveCriticalSection (&p_mutex->mutex);
223 }
224
225 /*** Condition variables ***/
226 void vlc_cond_init( vlc_cond_t *p_condvar )
227 {
228     /* Create a manual-reset event (manual reset is needed for broadcast). */
229     *p_condvar = CreateEvent (NULL, TRUE, FALSE, NULL);
230     if (!*p_condvar)
231         abort();
232 }
233
234 void vlc_cond_destroy (vlc_cond_t *p_condvar)
235 {
236     CloseHandle (*p_condvar);
237 }
238
239 void vlc_cond_signal (vlc_cond_t *p_condvar)
240 {
241     /* NOTE: This will cause a broadcast, that is wrong.
242      * This will also wake up the next waiting thread if no threads are yet
243      * waiting, which is also wrong. However both of these issues are allowed
244      * by the provision for spurious wakeups. Better have too many wakeups
245      * than too few (= deadlocks). */
246     SetEvent (*p_condvar);
247 }
248
249 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
250 {
251     SetEvent (*p_condvar);
252 }
253
254 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
255 {
256     DWORD result;
257
258     do
259     {
260         vlc_testcancel ();
261         LeaveCriticalSection (&p_mutex->mutex);
262         result = WaitForSingleObjectEx (*p_condvar, INFINITE, TRUE);
263         EnterCriticalSection (&p_mutex->mutex);
264     }
265     while (result == WAIT_IO_COMPLETION);
266
267     assert (result != WAIT_ABANDONED); /* another thread failed to cleanup! */
268     assert (result != WAIT_FAILED);
269     ResetEvent (*p_condvar);
270 }
271
272 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
273                         mtime_t deadline)
274 {
275     DWORD result;
276
277     do
278     {
279         vlc_testcancel ();
280
281         mtime_t total = (deadline - mdate ())/1000;
282         if( total < 0 )
283             total = 0;
284
285         DWORD delay = (total > 0x7fffffff) ? 0x7fffffff : total;
286         LeaveCriticalSection (&p_mutex->mutex);
287         result = WaitForSingleObjectEx (*p_condvar, delay, TRUE);
288         EnterCriticalSection (&p_mutex->mutex);
289     }
290     while (result == WAIT_IO_COMPLETION);
291
292     assert (result != WAIT_ABANDONED);
293     assert (result != WAIT_FAILED);
294     ResetEvent (*p_condvar);
295
296     return (result == WAIT_OBJECT_0) ? 0 : ETIMEDOUT;
297 }
298
299 /*** Semaphore ***/
300 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
301 {
302     *sem = CreateSemaphore (NULL, value, 0x7fffffff, NULL);
303     if (*sem == NULL)
304         abort ();
305 }
306
307 void vlc_sem_destroy (vlc_sem_t *sem)
308 {
309     CloseHandle (*sem);
310 }
311
312 int vlc_sem_post (vlc_sem_t *sem)
313 {
314     ReleaseSemaphore (*sem, 1, NULL);
315     return 0; /* FIXME */
316 }
317
318 void vlc_sem_wait (vlc_sem_t *sem)
319 {
320     DWORD result;
321
322     do
323     {
324         vlc_testcancel ();
325         result = WaitForSingleObjectEx (*sem, INFINITE, TRUE);
326     }
327     while (result == WAIT_IO_COMPLETION);
328 }
329
330 /*** Read/write locks */
331 /* SRW (Slim Read Write) locks are available in Vista+ only */
332 void vlc_rwlock_init (vlc_rwlock_t *lock)
333 {
334     vlc_mutex_init (&lock->mutex);
335     vlc_cond_init (&lock->read_wait);
336     vlc_cond_init (&lock->write_wait);
337     lock->readers = 0; /* active readers */
338     lock->writers = 0; /* waiting or active writers */
339     lock->writer = 0; /* ID of active writer */
340 }
341
342 /**
343  * Destroys an initialized unused read/write lock.
344  */
345 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
346 {
347     vlc_cond_destroy (&lock->read_wait);
348     vlc_cond_destroy (&lock->write_wait);
349     vlc_mutex_destroy (&lock->mutex);
350 }
351
352 /**
353  * Acquires a read/write lock for reading. Recursion is allowed.
354  */
355 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
356 {
357     vlc_mutex_lock (&lock->mutex);
358     while (lock->writer != 0)
359         vlc_cond_wait (&lock->read_wait, &lock->mutex);
360     if (lock->readers == ULONG_MAX)
361         abort ();
362     lock->readers++;
363     vlc_mutex_unlock (&lock->mutex);
364 }
365
366 /**
367  * Acquires a read/write lock for writing. Recursion is not allowed.
368  */
369 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
370 {
371     vlc_mutex_lock (&lock->mutex);
372     if (lock->writers == ULONG_MAX)
373         abort ();
374     lock->writers++;
375     while ((lock->readers > 0) || (lock->writer != 0))
376         vlc_cond_wait (&lock->write_wait, &lock->mutex);
377     lock->writers--;
378     lock->writer = GetCurrentThreadId ();
379     vlc_mutex_unlock (&lock->mutex);
380 }
381
382 /**
383  * Releases a read/write lock.
384  */
385 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
386 {
387     vlc_mutex_lock (&lock->mutex);
388     if (lock->readers > 0)
389         lock->readers--; /* Read unlock */
390     else
391         lock->writer = 0; /* Write unlock */
392
393     if (lock->writers > 0)
394     {
395         if (lock->readers == 0)
396             vlc_cond_signal (&lock->write_wait);
397     }
398     else
399         vlc_cond_broadcast (&lock->read_wait);
400     vlc_mutex_unlock (&lock->mutex);
401 }
402
403 /*** Thread-specific variables (TLS) ***/
404 int vlc_threadvar_create (vlc_threadvar_t *p_tls, void (*destr) (void *))
405 {
406 #warning FIXME: use destr() callback and stop leaking!
407     VLC_UNUSED( destr );
408
409     *p_tls = TlsAlloc();
410     return (*p_tls == TLS_OUT_OF_INDEXES) ? EAGAIN : 0;
411 }
412
413 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
414 {
415     TlsFree (*p_tls);
416 }
417
418 /**
419  * Sets a thread-local variable.
420  * @param key thread-local variable key (created with vlc_threadvar_create())
421  * @param value new value for the variable for the calling thread
422  * @return 0 on success, a system error code otherwise.
423  */
424 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
425 {
426     return TlsSetValue (key, value) ? ENOMEM : 0;
427 }
428
429 /**
430  * Gets the value of a thread-local variable for the calling thread.
431  * This function cannot fail.
432  * @return the value associated with the given variable for the calling
433  * or NULL if there is no value.
434  */
435 void *vlc_threadvar_get (vlc_threadvar_t key)
436 {
437     return TlsGetValue (key);
438 }
439
440
441 /*** Threads ***/
442 void vlc_threads_setup (libvlc_int_t *p_libvlc)
443 {
444     (void) p_libvlc;
445 }
446
447 struct vlc_entry_data
448 {
449     void * (*func) (void *);
450     void *  data;
451 #ifdef UNDER_CE
452     HANDLE  cancel_event;
453 #endif
454 };
455
456 static unsigned __stdcall vlc_entry (void *p)
457 {
458     vlc_cancel_t cancel_data = VLC_CANCEL_INIT;
459     struct vlc_entry_data data;
460
461     memcpy (&data, p, sizeof (data));
462     free (p);
463
464 #ifdef UNDER_CE
465     cancel_data.cancel_event = data.cancel_event;
466 #endif
467
468     vlc_threadvar_set (cancel_key, &cancel_data);
469     data.func (data.data);
470     return 0;
471 }
472
473 int vlc_clone (vlc_thread_t *p_handle, void * (*entry) (void *), void *data,
474                int priority)
475 {
476     int err = ENOMEM;
477     HANDLE hThread;
478
479     struct vlc_entry_data *entry_data = malloc (sizeof (*entry_data));
480     if (entry_data == NULL)
481         return ENOMEM;
482     entry_data->func = entry;
483     entry_data->data = data;
484
485 #ifndef UNDER_CE
486     /* When using the MSVCRT C library you have to use the _beginthreadex
487      * function instead of CreateThread, otherwise you'll end up with
488      * memory leaks and the signal functions not working (see Microsoft
489      * Knowledge Base, article 104641) */
490     hThread = (HANDLE)(uintptr_t)
491         _beginthreadex (NULL, 0, vlc_entry, entry_data, CREATE_SUSPENDED, NULL);
492     if (! hThread)
493     {
494         err = errno;
495         goto error;
496     }
497
498     /* Thread closes the handle when exiting, duplicate it here
499      * to be on the safe side when joining. */
500     if (!DuplicateHandle (GetCurrentProcess (), hThread,
501                           GetCurrentProcess (), p_handle, 0, FALSE,
502                           DUPLICATE_SAME_ACCESS))
503     {
504         CloseHandle (hThread);
505         goto error;
506     }
507
508 #else
509     vlc_thread_t th = malloc (sizeof (*th));
510     if (th == NULL)
511         goto error;
512     th->cancel_event = CreateEvent (NULL, FALSE, FALSE, NULL);
513     if (th->cancel_event == NULL)
514     {
515         free (th);
516         goto error;
517     }
518     entry_data->cancel_event = th->cancel_event;
519
520     /* Not sure if CREATE_SUSPENDED + ResumeThread() is any useful on WinCE.
521      * Thread handles act up, too. */
522     th->handle = CreateThread (NULL, 128*1024, vlc_entry, entry_data,
523                                CREATE_SUSPENDED, NULL);
524     if (th->handle == NULL)
525     {
526         CloseHandle (th->cancel_event);
527         free (th);
528         goto error;
529     }
530
531     *p_handle = th;
532     hThread = th->handle;
533
534 #endif
535
536     ResumeThread (hThread);
537     if (priority)
538         SetThreadPriority (hThread, priority);
539
540     return 0;
541
542 error:
543     free (entry_data);
544     return err;
545 }
546
547 void vlc_join (vlc_thread_t handle, void **result)
548 {
549 #ifdef UNDER_CE
550 # define handle handle->handle
551 #endif
552     do
553         vlc_testcancel ();
554     while (WaitForSingleObjectEx (handle, INFINITE, TRUE)
555                                                         == WAIT_IO_COMPLETION);
556
557     CloseHandle (handle);
558     assert (result == NULL); /* <- FIXME if ever needed */
559 #ifdef UNDER_CE
560 # undef handle
561     CloseHandle (handle->cancel_event);
562     free (handle);
563 #endif
564 }
565
566 void vlc_detach (vlc_thread_t handle)
567 {
568 #ifndef UNDER_CE
569     CloseHandle (handle);
570 #else
571     /* FIXME: handle->cancel_event leak */
572     CloseHandle (handle->handle);
573     free (handle);
574 #endif
575 }
576
577 /*** Thread cancellation ***/
578
579 /* APC procedure for thread cancellation */
580 static void CALLBACK vlc_cancel_self (ULONG_PTR dummy)
581 {
582     (void)dummy;
583     vlc_control_cancel (VLC_DO_CANCEL);
584 }
585
586 void vlc_cancel (vlc_thread_t thread_id)
587 {
588 #ifndef UNDER_CE
589     QueueUserAPC (vlc_cancel_self, thread_id, 0);
590 #else
591     SetEvent (thread_id->cancel_event);
592 #endif
593 }
594
595 int vlc_savecancel (void)
596 {
597     int state;
598
599     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
600     if (nfo == NULL)
601         return false; /* Main thread - cannot be cancelled anyway */
602
603     state = nfo->killable;
604     nfo->killable = false;
605     return state;
606 }
607
608 void vlc_restorecancel (int state)
609 {
610     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
611     assert (state == false || state == true);
612
613     if (nfo == NULL)
614         return; /* Main thread - cannot be cancelled anyway */
615
616     assert (!nfo->killable);
617     nfo->killable = state != 0;
618 }
619
620 void vlc_testcancel (void)
621 {
622     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
623     if (nfo == NULL)
624         return; /* Main thread - cannot be cancelled anyway */
625
626     if (nfo->killable && nfo->killed)
627     {
628         for (vlc_cleanup_t *p = nfo->cleaners; p != NULL; p = p->next)
629              p->proc (p->data);
630 #ifndef UNDER_CE
631         _endthread ();
632 #else
633         ExitThread(0);
634 #endif
635     }
636 }
637
638 void vlc_control_cancel (int cmd, ...)
639 {
640     /* NOTE: This function only modifies thread-specific data, so there is no
641      * need to lock anything. */
642     va_list ap;
643
644     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
645     if (nfo == NULL)
646         return; /* Main thread - cannot be cancelled anyway */
647
648     va_start (ap, cmd);
649     switch (cmd)
650     {
651         case VLC_DO_CANCEL:
652             nfo->killed = true;
653             break;
654
655         case VLC_CLEANUP_PUSH:
656         {
657             /* cleaner is a pointer to the caller stack, no need to allocate
658              * and copy anything. As a nice side effect, this cannot fail. */
659             vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
660             cleaner->next = nfo->cleaners;
661             nfo->cleaners = cleaner;
662             break;
663         }
664
665         case VLC_CLEANUP_POP:
666         {
667             nfo->cleaners = nfo->cleaners->next;
668             break;
669         }
670     }
671     va_end (ap);
672 }
673
674
675 /*** Timers ***/
676 struct vlc_timer
677 {
678 #ifndef UNDER_CE
679     HANDLE handle;
680 #else
681     unsigned id;
682     unsigned interval;
683 #endif
684     void (*func) (void *);
685     void *data;
686 };
687
688 #ifndef UNDER_CE
689 static void CALLBACK vlc_timer_do (void *val, BOOLEAN timeout)
690 {
691     struct vlc_timer *timer = val;
692
693     assert (timeout);
694     timer->func (timer->data);
695 }
696 #else
697 static void CALLBACK vlc_timer_do (unsigned timer_id, unsigned msg,
698                                    DWORD_PTR user, DWORD_PTR unused1,
699                                    DWORD_PTR unused2)
700 {
701     struct vlc_timer *timer = (struct vlc_timer *) user;
702     assert (timer_id == timer->id);
703     (void) msg;
704     (void) unused1;
705     (void) unused2;
706
707     timer->func (timer->data);
708
709     if (timer->interval)
710     {
711         mtime_t interval = timer->interval * 1000;
712         vlc_timer_schedule (timer, false, interval, interval);
713     }
714 }
715 #endif
716
717 int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
718 {
719     struct vlc_timer *timer = malloc (sizeof (*timer));
720
721     if (timer == NULL)
722         return ENOMEM;
723     timer->func = func;
724     timer->data = data;
725 #ifndef UNDER_CE
726     timer->handle = INVALID_HANDLE_VALUE;
727 #else
728     timer->id = 0;
729     timer->interval = 0;
730 #endif
731     *id = timer;
732     return 0;
733 }
734
735 void vlc_timer_destroy (vlc_timer_t timer)
736 {
737 #ifndef UNDER_CE
738     if (timer->handle != INVALID_HANDLE_VALUE)
739         DeleteTimerQueueTimer (NULL, timer->handle, INVALID_HANDLE_VALUE);
740 #else
741     if (timer->id)
742         timeKillEvent (timer->id);
743     /* FIXME: timers that have not yet completed will trigger use-after-free */
744 #endif
745     free (timer);
746 }
747
748 void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
749                          mtime_t value, mtime_t interval)
750 {
751 #ifndef UNDER_CE
752     if (timer->handle != INVALID_HANDLE_VALUE)
753     {
754         DeleteTimerQueueTimer (NULL, timer->handle, NULL);
755         timer->handle = INVALID_HANDLE_VALUE;
756     }
757 #else
758     if (timer->id)
759     {
760         timeKillEvent (timer->id);
761         timer->id = 0;
762         timer->interval = 0;
763     }
764 #endif
765     if (value == 0)
766         return; /* Disarm */
767
768     if (absolute)
769         value -= mdate ();
770     value = (value + 999) / 1000;
771     interval = (interval + 999) / 1000;
772
773 #ifndef UNDER_CE
774     if (!CreateTimerQueueTimer (&timer->handle, NULL, vlc_timer_do, timer,
775                                 value, interval, WT_EXECUTEDEFAULT))
776 #else
777     TIMECAPS caps;
778     timeGetDevCaps (&caps, sizeof(caps));
779
780     unsigned delay = value;
781     delay = __MAX(delay, caps.wPeriodMin);
782     delay = __MIN(delay, caps.wPeriodMax);
783
784     unsigned event = TIME_ONESHOT;
785
786     if (interval == delay)
787         event = TIME_PERIODIC;
788     else if (interval)
789         timer->interval = interval;
790
791     timer->id = timeSetEvent (delay, delay / 20, vlc_timer_do, (DWORD) timer,
792                               event);
793     if (!timer->id)
794 #endif
795         abort ();
796 }
797
798 unsigned vlc_timer_getoverrun (vlc_timer_t timer)
799 {
800     (void)timer;
801     return 0;
802 }