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