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