git.sesse.net Git - vlc/blob - 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 /*** Read/write locks */
 300 /* SRW (Slim Read Write) locks are available in Vista+ only */
 301 void vlc_rwlock_init (vlc_rwlock_t *lock)
 302 {
 303     vlc_mutex_init (&lock->mutex);
 304     vlc_cond_init (&lock->read_wait);
 305     vlc_cond_init (&lock->write_wait);
 306     lock->readers = 0; /* active readers */
 307     lock->writers = 0; /* waiting or active writers */
 308     lock->writer = 0; /* ID of active writer */
 309 }
 310
 311 /**
 312  * Destroys an initialized unused read/write lock.
 313  */
 314 void vlc_rwlock_destroy (vlc_rwlock_t *lock)
 315 {
 316     vlc_cond_destroy (&lock->read_wait);
 317     vlc_cond_destroy (&lock->write_wait);
 318     vlc_mutex_destroy (&lock->mutex);
 319 }
 320
 321 /**
 322  * Acquires a read/write lock for reading. Recursion is allowed.
 323  */
 324 void vlc_rwlock_rdlock (vlc_rwlock_t *lock)
 325 {
 326     vlc_mutex_lock (&lock->mutex);
 327     while (lock->writer != 0)
 328         vlc_cond_wait (&lock->read_wait, &lock->mutex);
 329     if (lock->readers == ULONG_MAX)
 330         abort ();
 331     lock->readers++;
 332     vlc_mutex_unlock (&lock->mutex);
 333 }
 334
 335 /**
 336  * Acquires a read/write lock for writing. Recursion is not allowed.
 337  */
 338 void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
 339 {
 340     vlc_mutex_lock (&lock->mutex);
 341     if (lock->writers == ULONG_MAX)
 342         abort ();
 343     lock->writers++;
 344     while ((lock->readers > 0) || (lock->writer != 0))
 345         vlc_cond_wait (&lock->write_wait, &lock->mutex);
 346     lock->writers--;
 347     lock->writer = GetCurrentThreadId ();
 348     vlc_mutex_unlock (&lock->mutex);
 349 }
 350
 351 /**
 352  * Releases a read/write lock.
 353  */
 354 void vlc_rwlock_unlock (vlc_rwlock_t *lock)
 355 {
 356     vlc_mutex_lock (&lock->mutex);
 357     if (lock->readers > 0)
 358         lock->readers--; /* Read unlock */
 359     else
 360         lock->writer = 0; /* Write unlock */
 361
 362     if (lock->writers > 0)
 363     {
 364         if (lock->readers == 0)
 365             vlc_cond_signal (&lock->write_wait);
 366     }
 367     else
 368         vlc_cond_broadcast (&lock->read_wait);
 369     vlc_mutex_unlock (&lock->mutex);
 370 }
 371
 372 /*** Thread-specific variables (TLS) ***/
 373 int vlc_threadvar_create (vlc_threadvar_t *p_tls, void (*destr) (void *))
 374 {
 375 #warning FIXME: use destr() callback and stop leaking!
 376
 377     *p_tls = TlsAlloc();
 378     return (*p_tls == TLS_OUT_OF_INDEXES) ? EAGAIN : 0;
 379 }
 380
 381 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
 382 {
 383     TlsFree (*p_tls);
 384 }
 385
 386 /**
 387  * Sets a thread-local variable.
 388  * @param key thread-local variable key (created with vlc_threadvar_create())
 389  * @param value new value for the variable for the calling thread
 390  * @return 0 on success, a system error code otherwise.
 391  */
 392 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
 393 {
 394     return TlsSetValue (key, value) ? ENOMEM : 0;
 395 }
 396
 397 /**
 398  * Gets the value of a thread-local variable for the calling thread.
 399  * This function cannot fail.
 400  * @return the value associated with the given variable for the calling
 401  * or NULL if there is no value.
 402  */
 403 void *vlc_threadvar_get (vlc_threadvar_t key)
 404 {
 405     return TlsGetValue (key);
 406 }
 407
 408
 409 /*** Threads ***/
 410 void vlc_threads_setup (libvlc_int_t *p_libvlc)
 411 {
 412     (void) p_libvlc;
 413 }
 414
 415 struct vlc_entry_data
 416 {
 417     void * (*func) (void *);
 418     void *  data;
 419 #ifdef UNDER_CE
 420     HANDLE  cancel_event;
 421 #endif
 422 };
 423
 424 static unsigned __stdcall vlc_entry (void *p)
 425 {
 426     vlc_cancel_t cancel_data = VLC_CANCEL_INIT;
 427     struct vlc_entry_data data;
 428
 429     memcpy (&data, p, sizeof (data));
 430     free (p);
 431
 432 #ifdef UNDER_CE
 433     cancel_data.cancel_event = data.cancel_event;
 434 #endif
 435
 436     vlc_threadvar_set (cancel_key, &cancel_data);
 437     data.func (data.data);
 438     return 0;
 439 }
 440
 441 int vlc_clone (vlc_thread_t *p_handle, void * (*entry) (void *), void *data,
 442                int priority)
 443 {
 444     int err = ENOMEM;
 445     HANDLE hThread;
 446
 447     struct vlc_entry_data *entry_data = malloc (sizeof (*entry_data));
 448     if (entry_data == NULL)
 449         return ENOMEM;
 450     entry_data->func = entry;
 451     entry_data->data = data;
 452
 453 #ifndef UNDER_CE
 454     /* When using the MSVCRT C library you have to use the _beginthreadex
 455      * function instead of CreateThread, otherwise you'll end up with
 456      * memory leaks and the signal functions not working (see Microsoft
 457      * Knowledge Base, article 104641) */
 458     hThread = (HANDLE)(uintptr_t)
 459         _beginthreadex (NULL, 0, vlc_entry, entry_data, CREATE_SUSPENDED, NULL);
 460     if (! hThread)
 461     {
 462         err = errno;
 463         goto error;
 464     }
 465
 466     /* Thread closes the handle when exiting, duplicate it here
 467      * to be on the safe side when joining. */
 468     if (!DuplicateHandle (GetCurrentProcess (), hThread,
 469                           GetCurrentProcess (), p_handle, 0, FALSE,
 470                           DUPLICATE_SAME_ACCESS))
 471     {
 472         CloseHandle (hThread);
 473         goto error;
 474     }
 475
 476 #else
 477     vlc_thread_t th = malloc (sizeof (*th));
 478     if (th == NULL)
 479         goto error;
 480     th->cancel_event = CreateEvent (NULL, FALSE, FALSE, NULL);
 481     if (th->cancel_event == NULL)
 482     {
 483         free (th);
 484         goto error;
 485     }
 486     entry_data->cancel_event = th->cancel_event;
 487
 488     /* Not sure if CREATE_SUSPENDED + ResumeThread() is any useful on WinCE.
 489      * Thread handles act up, too. */
 490     th->handle = CreateThread (NULL, 128*1024, vlc_entry, entry_data,
 491                                CREATE_SUSPENDED, NULL);
 492     if (th->handle == NULL)
 493     {
 494         CloseHandle (th->cancel_event);
 495         free (th);
 496         goto error;
 497     }
 498
 499     *p_handle = th;
 500     hThread = th->handle;
 501
 502 #endif
 503
 504     ResumeThread (hThread);
 505     if (priority)
 506         SetThreadPriority (hThread, priority);
 507
 508     return 0;
 509
 510 error:
 511     free (entry_data);
 512     return err;
 513 }
 514
 515 void vlc_join (vlc_thread_t handle, void **result)
 516 {
 517 #ifdef UNDER_CE
 518 # define handle handle->handle
 519 #endif
 520     do
 521         vlc_testcancel ();
 522     while (WaitForSingleObjectEx (handle, INFINITE, TRUE)
 523                                                         == WAIT_IO_COMPLETION);
 524
 525     CloseHandle (handle);
 526     assert (result == NULL); /* <- FIXME if ever needed */
 527 #ifdef UNDER_CE
 528 # undef handle
 529     CloseHandle (handle->cancel_event);
 530     free (handle);
 531 #endif
 532 }
 533
 534 void vlc_detach (vlc_thread_t handle)
 535 {
 536 #ifndef UNDER_CE
 537     CloseHandle (handle);
 538 #else
 539     /* FIXME: handle->cancel_event leak */
 540     CloseHandle (handle->handle);
 541     free (handle);
 542 #endif
 543 }
 544
 545 /*** Thread cancellation ***/
 546
 547 /* APC procedure for thread cancellation */
 548 static void CALLBACK vlc_cancel_self (ULONG_PTR dummy)
 549 {
 550     (void)dummy;
 551     vlc_control_cancel (VLC_DO_CANCEL);
 552 }
 553
 554 void vlc_cancel (vlc_thread_t thread_id)
 555 {
 556 #ifndef UNDER_CE
 557     QueueUserAPC (vlc_cancel_self, thread_id, 0);
 558 #else
 559     SetEvent (thread_id->cancel_event);
 560 #endif
 561 }
 562
 563 int vlc_savecancel (void)
 564 {
 565     int state;
 566
 567     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
 568     if (nfo == NULL)
 569         return false; /* Main thread - cannot be cancelled anyway */
 570
 571     state = nfo->killable;
 572     nfo->killable = false;
 573     return state;
 574 }
 575
 576 void vlc_restorecancel (int state)
 577 {
 578     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
 579     assert (state == false || state == true);
 580
 581     if (nfo == NULL)
 582         return; /* Main thread - cannot be cancelled anyway */
 583
 584     assert (!nfo->killable);
 585     nfo->killable = state != 0;
 586 }
 587
 588 void vlc_testcancel (void)
 589 {
 590     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
 591     if (nfo == NULL)
 592         return; /* Main thread - cannot be cancelled anyway */
 593
 594     if (nfo->killable && nfo->killed)
 595     {
 596         for (vlc_cleanup_t *p = nfo->cleaners; p != NULL; p = p->next)
 597              p->proc (p->data);
 598 #ifndef UNDER_CE
 599         _endthread ();
 600 #else
 601         ExitThread(0);
 602 #endif
 603     }
 604 }
 605
 606 void vlc_control_cancel (int cmd, ...)
 607 {
 608     /* NOTE: This function only modifies thread-specific data, so there is no
 609      * need to lock anything. */
 610     va_list ap;
 611
 612     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
 613     if (nfo == NULL)
 614         return; /* Main thread - cannot be cancelled anyway */
 615
 616     va_start (ap, cmd);
 617     switch (cmd)
 618     {
 619         case VLC_DO_CANCEL:
 620             nfo->killed = true;
 621             break;
 622
 623         case VLC_CLEANUP_PUSH:
 624         {
 625             /* cleaner is a pointer to the caller stack, no need to allocate
 626              * and copy anything. As a nice side effect, this cannot fail. */
 627             vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
 628             cleaner->next = nfo->cleaners;
 629             nfo->cleaners = cleaner;
 630             break;
 631         }
 632
 633         case VLC_CLEANUP_POP:
 634         {
 635             nfo->cleaners = nfo->cleaners->next;
 636             break;
 637         }
 638     }
 639     va_end (ap);
 640 }
 641
 642
 643 /*** Timers ***/
 644 struct vlc_timer
 645 {
 646 #ifndef UNDER_CE
 647     HANDLE handle;
 648 #else
 649     unsigned id;
 650     unsigned interval;
 651 #endif
 652     void (*func) (void *);
 653     void *data;
 654 };
 655
 656 #ifndef UNDER_CE
 657 static void CALLBACK vlc_timer_do (void *val, BOOLEAN timeout)
 658 {
 659     struct vlc_timer *timer = val;
 660
 661     assert (timeout);
 662     timer->func (timer->data);
 663 }
 664 #else
 665 static void CALLBACK vlc_timer_do (unsigned timer_id, unsigned msg,
 666                                    DWORD_PTR user, DWORD_PTR unused1,
 667                                    DWORD_PTR unused2)
 668 {
 669     struct vlc_timer *timer = (struct vlc_timer *) user;
 670     assert (timer_id == timer->id);
 671     (void) msg;
 672     (void) unused1;
 673     (void) unused2;
 674
 675     timer->func (timer->data);
 676
 677     if (timer->interval)
 678     {
 679         mtime_t interval = timer->interval * 1000;
 680         vlc_timer_schedule (timer, false, interval, interval);
 681     }
 682 }
 683 #endif
 684
 685 int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
 686 {
 687     struct vlc_timer *timer = malloc (sizeof (*timer));
 688
 689     if (timer == NULL)
 690         return ENOMEM;
 691     timer->func = func;
 692     timer->data = data;
 693 #ifndef UNDER_CE
 694     timer->handle = INVALID_HANDLE_VALUE;
 695 #else
 696     timer->id = 0;
 697     timer->interval = 0;
 698 #endif
 699     *id = timer;
 700     return 0;
 701 }
 702
 703 void vlc_timer_destroy (vlc_timer_t timer)
 704 {
 705 #ifndef UNDER_CE
 706     if (timer->handle != INVALID_HANDLE_VALUE)
 707         DeleteTimerQueueTimer (NULL, timer->handle, INVALID_HANDLE_VALUE);
 708 #else
 709     if (timer->id)
 710         timeKillEvent (timer->id);
 711     /* FIXME: timers that have not yet completed will trigger use-after-free */
 712 #endif
 713     free (timer);
 714 }
 715
 716 void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
 717                          mtime_t value, mtime_t interval)
 718 {
 719 #ifndef UNDER_CE
 720     if (timer->handle != INVALID_HANDLE_VALUE)
 721     {
 722         DeleteTimerQueueTimer (NULL, timer->handle, NULL);
 723         timer->handle = INVALID_HANDLE_VALUE;
 724     }
 725 #else
 726     if (timer->id)
 727     {
 728         timeKillEvent (timer->id);
 729         timer->id = 0;
 730         timer->interval = 0;
 731     }
 732 #endif
 733     if (value == 0)
 734         return; /* Disarm */
 735
 736     if (absolute)
 737         value -= mdate ();
 738     value = (value + 999) / 1000;
 739     interval = (interval + 999) / 1000;
 740
 741 #ifndef UNDER_CE
 742     if (!CreateTimerQueueTimer (&timer->handle, NULL, vlc_timer_do, timer,
 743                                 value, interval, WT_EXECUTEDEFAULT))
 744 #else
 745     TIMECAPS caps;
 746     timeGetDevCaps (&caps, sizeof(caps));
 747
 748     unsigned delay = value;
 749     delay = __MAX(delay, caps.wPeriodMin);
 750     delay = __MIN(delay, caps.wPeriodMax);
 751
 752     unsigned event = TIME_ONESHOT;
 753
 754     if (interval == delay)
 755         event = TIME_PERIODIC;
 756     else if (interval)
 757         timer->interval = interval;
 758
 759     timer->id = timeSetEvent (delay, delay / 20, vlc_timer_do, (DWORD) timer,
 760                               event);
 761     if (!timer->id)
 762 #endif
 763         abort ();
 764 }
 765
 766 unsigned vlc_timer_getoverrun (vlc_timer_t timer)
 767 {
 768     (void)timer;
 769     return 0;
 770 }