git.sesse.net Git - vlc/blob - src/win32/thread.c

   1 /*****************************************************************************
   2  * thread.c : Win32 back-end for LibVLC
   3  *****************************************************************************
   4  * Copyright (C) 1999-2009 VLC authors and VideoLAN
   5  *
   6  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
   7  *          Samuel Hocevar <sam@zoy.org>
   8  *          Gildas Bazin <gbazin@netcourrier.com>
   9  *          Clément Sténac
  10  *          Rémi Denis-Courmont
  11  *          Pierre Ynard
  12  *
  13  * This program is free software; you can redistribute it and/or modify it
  14  * under the terms of the GNU Lesser General Public License as published by
  15  * the Free Software Foundation; either version 2.1 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21  * GNU Lesser General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Lesser General Public License
  24  * along with this program; if not, write to the Free Software Foundation,
  25  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33
  34 #include "libvlc.h"
  35 #include <stdarg.h>
  36 #include <assert.h>
  37 #include <limits.h>
  38 #include <errno.h>
  39
  40 /*** Static mutex and condition variable ***/
  41 static vlc_mutex_t super_mutex;
  42 static vlc_cond_t  super_variable;
  43
  44
  45 /*** Common helpers ***/
  46 static DWORD vlc_WaitForMultipleObjects (DWORD count, const HANDLE *handles,
  47                                          DWORD delay)
  48 {
  49     DWORD ret;
  50     if (count == 0)
  51     {
  52         ret = SleepEx (delay, TRUE);
  53         if (ret == 0)
  54             ret = WAIT_TIMEOUT;
  55     }
  56     else
  57         ret = WaitForMultipleObjectsEx (count, handles, FALSE, delay, TRUE);
  58
  59     /* We do not abandon objects... this would be a bug */
  60     assert (ret < WAIT_ABANDONED_0 || WAIT_ABANDONED_0 + count - 1 < ret);
  61
  62     if (unlikely(ret == WAIT_FAILED))
  63         abort (); /* We are screwed! */
  64     return ret;
  65 }
  66
  67 static DWORD vlc_WaitForSingleObject (HANDLE handle, DWORD delay)
  68 {
  69     return vlc_WaitForMultipleObjects (1, &handle, delay);
  70 }
  71
  72 static DWORD vlc_Sleep (DWORD delay)
  73 {
  74     DWORD ret = vlc_WaitForMultipleObjects (0, NULL, delay);
  75     return (ret != WAIT_TIMEOUT) ? ret : 0;
  76 }
  77
  78
  79 /*** Mutexes ***/
  80 void vlc_mutex_init( vlc_mutex_t *p_mutex )
  81 {
  82     /* This creates a recursive mutex. This is OK as fast mutexes have
  83      * no defined behavior in case of recursive locking. */
  84     InitializeCriticalSection (&p_mutex->mutex);
  85     p_mutex->dynamic = true;
  86 }
  87
  88 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
  89 {
  90     InitializeCriticalSection( &p_mutex->mutex );
  91     p_mutex->dynamic = true;
  92 }
  93
  94
  95 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
  96 {
  97     assert (p_mutex->dynamic);
  98     DeleteCriticalSection (&p_mutex->mutex);
  99 }
 100
 101 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
 102 {
 103     if (!p_mutex->dynamic)
 104     {   /* static mutexes */
 105         int canc = vlc_savecancel ();
 106         assert (p_mutex != &super_mutex); /* this one cannot be static */
 107
 108         vlc_mutex_lock (&super_mutex);
 109         while (p_mutex->locked)
 110         {
 111             p_mutex->contention++;
 112             vlc_cond_wait (&super_variable, &super_mutex);
 113             p_mutex->contention--;
 114         }
 115         p_mutex->locked = true;
 116         vlc_mutex_unlock (&super_mutex);
 117         vlc_restorecancel (canc);
 118         return;
 119     }
 120
 121     EnterCriticalSection (&p_mutex->mutex);
 122 }
 123
 124 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
 125 {
 126     if (!p_mutex->dynamic)
 127     {   /* static mutexes */
 128         int ret = EBUSY;
 129
 130         assert (p_mutex != &super_mutex); /* this one cannot be static */
 131         vlc_mutex_lock (&super_mutex);
 132         if (!p_mutex->locked)
 133         {
 134             p_mutex->locked = true;
 135             ret = 0;
 136         }
 137         vlc_mutex_unlock (&super_mutex);
 138         return ret;
 139     }
 140
 141     return TryEnterCriticalSection (&p_mutex->mutex) ? 0 : EBUSY;
 142 }
 143
 144 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
 145 {
 146     if (!p_mutex->dynamic)
 147     {   /* static mutexes */
 148         assert (p_mutex != &super_mutex); /* this one cannot be static */
 149
 150         vlc_mutex_lock (&super_mutex);
 151         assert (p_mutex->locked);
 152         p_mutex->locked = false;
 153         if (p_mutex->contention)
 154             vlc_cond_broadcast (&super_variable);
 155         vlc_mutex_unlock (&super_mutex);
 156         return;
 157     }
 158
 159     LeaveCriticalSection (&p_mutex->mutex);
 160 }
 161
 162 /*** Condition variables ***/
 163 enum
 164 {
 165     VLC_CLOCK_STATIC=0, /* must be zero for VLC_STATIC_COND */
 166     VLC_CLOCK_MONOTONIC,
 167     VLC_CLOCK_REALTIME,
 168 };
 169
 170 static void vlc_cond_init_common (vlc_cond_t *p_condvar, unsigned clock)
 171 {
 172     /* Create a manual-reset event (manual reset is needed for broadcast). */
 173     p_condvar->handle = CreateEvent (NULL, TRUE, FALSE, NULL);
 174     if (!p_condvar->handle)
 175         abort();
 176     p_condvar->clock = clock;
 177 }
 178
 179 void vlc_cond_init (vlc_cond_t *p_condvar)
 180 {
 181     vlc_cond_init_common (p_condvar, VLC_CLOCK_MONOTONIC);
 182 }
 183
 184 void vlc_cond_init_daytime (vlc_cond_t *p_condvar)
 185 {
 186     vlc_cond_init_common (p_condvar, VLC_CLOCK_REALTIME);
 187 }
 188
 189 void vlc_cond_destroy (vlc_cond_t *p_condvar)
 190 {
 191     CloseHandle (p_condvar->handle);
 192 }
 193
 194 void vlc_cond_signal (vlc_cond_t *p_condvar)
 195 {
 196     if (!p_condvar->clock)
 197         return;
 198
 199     /* This is suboptimal but works. */
 200     vlc_cond_broadcast (p_condvar);
 201 }
 202
 203 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
 204 {
 205     if (!p_condvar->clock)
 206         return;
 207
 208     /* Wake all threads up (as the event HANDLE has manual reset) */
 209     SetEvent (p_condvar->handle);
 210 }
 211
 212 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
 213 {
 214     DWORD result;
 215
 216     if (!p_condvar->clock)
 217     {   /* FIXME FIXME FIXME */
 218         msleep (50000);
 219         return;
 220     }
 221
 222     do
 223     {
 224         vlc_testcancel ();
 225         vlc_mutex_unlock (p_mutex);
 226         result = vlc_WaitForSingleObject (p_condvar->handle, INFINITE);
 227         vlc_mutex_lock (p_mutex);
 228     }
 229     while (result == WAIT_IO_COMPLETION);
 230
 231     ResetEvent (p_condvar->handle);
 232 }
 233
 234 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
 235                         mtime_t deadline)
 236 {
 237     DWORD result;
 238
 239     do
 240     {
 241         vlc_testcancel ();
 242
 243         mtime_t total;
 244         switch (p_condvar->clock)
 245         {
 246             case VLC_CLOCK_MONOTONIC:
 247                 total = mdate();
 248                 break;
 249             case VLC_CLOCK_REALTIME: /* FIXME? sub-second precision */
 250                 total = CLOCK_FREQ * time (NULL);
 251                 break;
 252             default:
 253                 assert (!p_condvar->clock);
 254                 /* FIXME FIXME FIXME */
 255                 msleep (50000);
 256                 return 0;
 257         }
 258         total = (deadline - total) / 1000;
 259         if( total < 0 )
 260             total = 0;
 261
 262         DWORD delay = (total > 0x7fffffff) ? 0x7fffffff : total;
 263         vlc_mutex_unlock (p_mutex);
 264         result = vlc_WaitForSingleObject (p_condvar->handle, delay);
 265         vlc_mutex_lock (p_mutex);
 266     }
 267     while (result == WAIT_IO_COMPLETION);
 268
 269     ResetEvent (p_condvar->handle);
 270
 271     return (result == WAIT_OBJECT_0) ? 0 : ETIMEDOUT;
 272 }
 273
 274 /*** Semaphore ***/
 275 void vlc_sem_init (vlc_sem_t *sem, unsigned value)
 276 {
 277     *sem = CreateSemaphore (NULL, value, 0x7fffffff, NULL);
 278     if (*sem == NULL)
 279         abort ();
 280 }
 281
 282 void vlc_sem_destroy (vlc_sem_t *sem)
 283 {
 284     CloseHandle (*sem);
 285 }
 286
 287 int vlc_sem_post (vlc_sem_t *sem)
 288 {
 289     ReleaseSemaphore (*sem, 1, NULL);
 290     return 0; /* FIXME */
 291 }
 292
 293 void vlc_sem_wait (vlc_sem_t *sem)
 294 {
 295     DWORD result;
 296
 297     do
 298     {
 299         vlc_testcancel ();
 300         result = vlc_WaitForSingleObject (*sem, INFINITE);
 301     }
 302     while (result == WAIT_IO_COMPLETION);
 303 }
 304
 305 /*** Thread-specific variables (TLS) ***/
 306 struct vlc_threadvar
 307 {
 308     DWORD                 id;
 309     void                (*destroy) (void *);
 310     struct vlc_threadvar *prev;
 311     struct vlc_threadvar *next;
 312 } *vlc_threadvar_last = NULL;
 313
 314 int vlc_threadvar_create (vlc_threadvar_t *p_tls, void (*destr) (void *))
 315 {
 316     struct vlc_threadvar *var = malloc (sizeof (*var));
 317     if (unlikely(var == NULL))
 318         return errno;
 319
 320     var->id = TlsAlloc();
 321     if (var->id == TLS_OUT_OF_INDEXES)
 322     {
 323         free (var);
 324         return EAGAIN;
 325     }
 326     var->destroy = destr;
 327     var->next = NULL;
 328     *p_tls = var;
 329
 330     vlc_mutex_lock (&super_mutex);
 331     var->prev = vlc_threadvar_last;
 332     if (var->prev)
 333         var->prev->next = var;
 334
 335     vlc_threadvar_last = var;
 336     vlc_mutex_unlock (&super_mutex);
 337     return 0;
 338 }
 339
 340 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
 341 {
 342     struct vlc_threadvar *var = *p_tls;
 343
 344     vlc_mutex_lock (&super_mutex);
 345     if (var->prev != NULL)
 346         var->prev->next = var->next;
 347
 348     if (var->next != NULL)
 349         var->next->prev = var->prev;
 350     else
 351         vlc_threadvar_last = var->prev;
 352
 353     vlc_mutex_unlock (&super_mutex);
 354
 355     TlsFree (var->id);
 356     free (var);
 357 }
 358
 359 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
 360 {
 361     int saved = GetLastError ();
 362     int val = TlsSetValue (key->id, value) ? ENOMEM : 0;
 363
 364     if (val == 0)
 365         SetLastError(saved);
 366     return val;
 367 }
 368
 369 void *vlc_threadvar_get (vlc_threadvar_t key)
 370 {
 371     int saved = GetLastError ();
 372     void *value = TlsGetValue (key->id);
 373
 374     SetLastError(saved);
 375     return value;
 376 }
 377
 378 /*** Threads ***/
 379 static vlc_threadvar_t thread_key;
 380
 381 /** Per-thread data */
 382 struct vlc_thread
 383 {
 384     HANDLE         id;
 385
 386     bool           detached;
 387     bool           killable;
 388     bool           killed;
 389     vlc_cleanup_t *cleaners;
 390
 391     void        *(*entry) (void *);
 392     void          *data;
 393 };
 394
 395 static void vlc_thread_cleanup (struct vlc_thread *th)
 396 {
 397     vlc_threadvar_t key;
 398
 399 retry:
 400     /* TODO: use RW lock or something similar */
 401     vlc_mutex_lock (&super_mutex);
 402     for (key = vlc_threadvar_last; key != NULL; key = key->prev)
 403     {
 404         void *value = vlc_threadvar_get (key);
 405         if (value != NULL && key->destroy != NULL)
 406         {
 407             vlc_mutex_unlock (&super_mutex);
 408             vlc_threadvar_set (key, NULL);
 409             key->destroy (value);
 410             goto retry;
 411         }
 412     }
 413     vlc_mutex_unlock (&super_mutex);
 414
 415     if (th->detached)
 416     {
 417         CloseHandle (th->id);
 418         free (th);
 419     }
 420 }
 421
 422 static unsigned __stdcall vlc_entry (void *p)
 423 {
 424     struct vlc_thread *th = p;
 425
 426     vlc_threadvar_set (thread_key, th);
 427     th->killable = true;
 428     th->data = th->entry (th->data);
 429     vlc_thread_cleanup (th);
 430     return 0;
 431 }
 432
 433 static int vlc_clone_attr (vlc_thread_t *p_handle, bool detached,
 434                            void *(*entry) (void *), void *data, int priority)
 435 {
 436     struct vlc_thread *th = malloc (sizeof (*th));
 437     if (unlikely(th == NULL))
 438         return ENOMEM;
 439     th->entry = entry;
 440     th->data = data;
 441     th->detached = detached;
 442     th->killable = false; /* not until vlc_entry() ! */
 443     th->killed = false;
 444     th->cleaners = NULL;
 445
 446     HANDLE hThread;
 447     /* When using the MSVCRT C library you have to use the _beginthreadex
 448      * function instead of CreateThread, otherwise you'll end up with
 449      * memory leaks and the signal functions not working (see Microsoft
 450      * Knowledge Base, article 104641) */
 451     uintptr_t h;
 452
 453     h = _beginthreadex (NULL, 0, vlc_entry, th, CREATE_SUSPENDED, NULL);
 454     if (h == 0)
 455     {
 456         int err = errno;
 457         free (th);
 458         return err;
 459     }
 460     hThread = (HANDLE)h;
 461
 462     /* Thread is suspended, so we can safely set th->id */
 463     th->id = hThread;
 464     if (p_handle != NULL)
 465         *p_handle = th;
 466
 467     if (priority)
 468         SetThreadPriority (hThread, priority);
 469
 470     ResumeThread (hThread);
 471
 472     return 0;
 473 }
 474
 475 int vlc_clone (vlc_thread_t *p_handle, void *(*entry) (void *),
 476                 void *data, int priority)
 477 {
 478     return vlc_clone_attr (p_handle, false, entry, data, priority);
 479 }
 480
 481 void vlc_join (vlc_thread_t th, void **result)
 482 {
 483     do
 484         vlc_testcancel ();
 485     while (vlc_WaitForSingleObject (th->id, INFINITE) == WAIT_IO_COMPLETION);
 486
 487     if (result != NULL)
 488         *result = th->data;
 489     CloseHandle (th->id);
 490     free (th);
 491 }
 492
 493 int vlc_clone_detach (vlc_thread_t *p_handle, void *(*entry) (void *),
 494                       void *data, int priority)
 495 {
 496     vlc_thread_t th;
 497     if (p_handle == NULL)
 498         p_handle = &th;
 499
 500     return vlc_clone_attr (p_handle, true, entry, data, priority);
 501 }
 502
 503 int vlc_set_priority (vlc_thread_t th, int priority)
 504 {
 505     if (!SetThreadPriority (th->id, priority))
 506         return VLC_EGENERIC;
 507     return VLC_SUCCESS;
 508 }
 509
 510 /*** Thread cancellation ***/
 511
 512 /* APC procedure for thread cancellation */
 513 static void CALLBACK vlc_cancel_self (ULONG_PTR self)
 514 {
 515     struct vlc_thread *th = (void *)self;
 516
 517     if (likely(th != NULL))
 518         th->killed = true;
 519 }
 520
 521 void vlc_cancel (vlc_thread_t th)
 522 {
 523     QueueUserAPC (vlc_cancel_self, th->id, (uintptr_t)th);
 524 }
 525
 526 int vlc_savecancel (void)
 527 {
 528     struct vlc_thread *th = vlc_threadvar_get (thread_key);
 529     if (th == NULL)
 530         return false; /* Main thread - cannot be cancelled anyway */
 531
 532     int state = th->killable;
 533     th->killable = false;
 534     return state;
 535 }
 536
 537 void vlc_restorecancel (int state)
 538 {
 539     struct vlc_thread *th = vlc_threadvar_get (thread_key);
 540     assert (state == false || state == true);
 541
 542     if (th == NULL)
 543         return; /* Main thread - cannot be cancelled anyway */
 544
 545     assert (!th->killable);
 546     th->killable = state != 0;
 547 }
 548
 549 void vlc_testcancel (void)
 550 {
 551     struct vlc_thread *th = vlc_threadvar_get (thread_key);
 552     if (th == NULL)
 553         return; /* Main thread - cannot be cancelled anyway */
 554
 555     if (th->killable && th->killed)
 556     {
 557         for (vlc_cleanup_t *p = th->cleaners; p != NULL; p = p->next)
 558              p->proc (p->data);
 559
 560         th->data = NULL; /* TODO: special value? */
 561         vlc_thread_cleanup (th);
 562         _endthreadex(0);
 563     }
 564 }
 565
 566 void vlc_control_cancel (int cmd, ...)
 567 {
 568     /* NOTE: This function only modifies thread-specific data, so there is no
 569      * need to lock anything. */
 570     va_list ap;
 571
 572     struct vlc_thread *th = vlc_threadvar_get (thread_key);
 573     if (th == NULL)
 574         return; /* Main thread - cannot be cancelled anyway */
 575
 576     va_start (ap, cmd);
 577     switch (cmd)
 578     {
 579         case VLC_CLEANUP_PUSH:
 580         {
 581             /* cleaner is a pointer to the caller stack, no need to allocate
 582              * and copy anything. As a nice side effect, this cannot fail. */
 583             vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
 584             cleaner->next = th->cleaners;
 585             th->cleaners = cleaner;
 586             break;
 587         }
 588
 589         case VLC_CLEANUP_POP:
 590         {
 591             th->cleaners = th->cleaners->next;
 592             break;
 593         }
 594     }
 595     va_end (ap);
 596 }
 597
 598 /*** Clock ***/
 599 static CRITICAL_SECTION clock_lock;
 600
 601 static mtime_t mdate_giveup (void)
 602 {
 603     abort ();
 604 }
 605
 606 static mtime_t (*mdate_selected) (void) = mdate_giveup;
 607
 608 mtime_t mdate (void)
 609 {
 610     return mdate_selected ();
 611 }
 612
 613 static union
 614 {
 615     struct
 616     {
 617 #if (_WIN32_WINNT < 0x0601)
 618         BOOL (*query) (PULONGLONG);
 619 #endif
 620     } interrupt;
 621     struct
 622     {
 623 #if (_WIN32_WINNT < 0x0600)
 624         ULONGLONG (*get) (void);
 625 #endif
 626     } tick;
 627     struct
 628     {
 629         LARGE_INTEGER freq;
 630     } perf;
 631 } clk;
 632
 633 static mtime_t mdate_interrupt (void)
 634 {
 635     ULONGLONG ts;
 636     BOOL ret;
 637
 638 #if (_WIN32_WINNT >= 0x0601)
 639     ret = QueryUnbiasedInterruptTime (&ts);
 640 #else
 641     ret = clk.interrupt.query (&ts);
 642 #endif
 643     if (unlikely(!ret))
 644         abort ();
 645
 646     /* hundreds of nanoseconds */
 647     static_assert ((10000000 % CLOCK_FREQ) == 0, "Broken frequencies ratio");
 648     return ts / (10000000 / CLOCK_FREQ);
 649 }
 650
 651 static mtime_t mdate_tick (void)
 652 {
 653 #if (_WIN32_WINNT >= 0x0600)
 654     ULONGLONG ts = GetTickCount64 ();
 655 #else
 656     ULONGLONG ts = clk.tick.get ();
 657 #endif
 658
 659     /* milliseconds */
 660     static_assert ((CLOCK_FREQ % 1000) == 0, "Broken frequencies ratio");
 661     return ts * (CLOCK_FREQ / 1000);
 662 }
 663 #if !VLC_WINSTORE_APP
 664 #include <mmsystem.h>
 665 static mtime_t mdate_multimedia (void)
 666 {
 667      DWORD ts = timeGetTime ();
 668
 669     /* milliseconds */
 670     static_assert ((CLOCK_FREQ % 1000) == 0, "Broken frequencies ratio");
 671     return ts * (CLOCK_FREQ / 1000);
 672 }
 673 #endif
 674
 675 static mtime_t mdate_perf (void)
 676 {
 677     /* We don't need the real date, just the value of a high precision timer */
 678     LARGE_INTEGER counter;
 679     if (!QueryPerformanceCounter (&counter))
 680         abort ();
 681
 682     /* Convert to from (1/freq) to microsecond resolution */
 683     /* We need to split the division to avoid 63-bits overflow */
 684     lldiv_t d = lldiv (counter.QuadPart, clk.perf.freq.QuadPart);
 685
 686     return (d.quot * 1000000) + ((d.rem * 1000000) / clk.perf.freq.QuadPart);
 687 }
 688
 689 static mtime_t mdate_wall (void)
 690 {
 691     FILETIME ts;
 692     ULARGE_INTEGER s;
 693
 694 #if (_WIN32_WINNT >= 0x0602) && !VLC_WINSTORE_APP
 695     GetSystemTimePreciseAsFileTime (&ts);
 696 #else
 697     GetSystemTimeAsFileTime (&ts);
 698 #endif
 699     s.LowPart = ts.dwLowDateTime;
 700     s.HighPart = ts.dwHighDateTime;
 701     /* hundreds of nanoseconds */
 702     static_assert ((10000000 % CLOCK_FREQ) == 0, "Broken frequencies ratio");
 703     return s.QuadPart / (10000000 / CLOCK_FREQ);
 704 }
 705
 706 #undef mwait
 707 void mwait (mtime_t deadline)
 708 {
 709     mtime_t delay;
 710
 711     vlc_testcancel();
 712     while ((delay = (deadline - mdate())) > 0)
 713     {
 714         delay /= 1000;
 715         if (unlikely(delay > 0x7fffffff))
 716             delay = 0x7fffffff;
 717         vlc_Sleep (delay);
 718         vlc_testcancel();
 719     }
 720 }
 721
 722 #undef msleep
 723 void msleep (mtime_t delay)
 724 {
 725     mwait (mdate () + delay);
 726 }
 727
 728 static void SelectClockSource (vlc_object_t *obj)
 729 {
 730     EnterCriticalSection (&clock_lock);
 731     if (mdate_selected != mdate_giveup)
 732     {
 733         LeaveCriticalSection (&clock_lock);
 734         return;
 735     }
 736
 737 #if VLC_WINSTORE_APP
 738     const char *name = "perf";
 739 #else
 740     const char *name = "multimedia";
 741 #endif
 742     char *str = var_InheritString (obj, "clock-source");
 743     if (str != NULL)
 744         name = str;
 745     if (!strcmp (name, "interrupt"))
 746     {
 747         msg_Dbg (obj, "using interrupt time as clock source");
 748 #if (_WIN32_WINNT < 0x0601)
 749         HANDLE h = GetModuleHandle (_T("kernel32.dll"));
 750         if (unlikely(h == NULL))
 751             abort ();
 752         clk.interrupt.query = (void *)GetProcAddress (h,
 753                                                       "QueryUnbiasedInterruptTime");
 754         if (unlikely(clk.interrupt.query == NULL))
 755             abort ();
 756 #endif
 757         mdate_selected = mdate_interrupt;
 758     }
 759     else
 760     if (!strcmp (name, "tick"))
 761     {
 762         msg_Dbg (obj, "using Windows time as clock source");
 763 #if (_WIN32_WINNT < 0x0600)
 764         HANDLE h = GetModuleHandle (_T("kernel32.dll"));
 765         if (unlikely(h == NULL))
 766             abort ();
 767         clk.tick.get = (void *)GetProcAddress (h, "GetTickCount64");
 768         if (unlikely(clk.tick.get == NULL))
 769             abort ();
 770 #endif
 771         mdate_selected = mdate_tick;
 772     }
 773 #if !VLC_WINSTORE_APP
 774     else
 775     if (!strcmp (name, "multimedia"))
 776     {
 777         TIMECAPS caps;
 778
 779         msg_Dbg (obj, "using multimedia timers as clock source");
 780         if (timeGetDevCaps (&caps, sizeof (caps)) != MMSYSERR_NOERROR)
 781             abort ();
 782         msg_Dbg (obj, " min period: %u ms, max period: %u ms",
 783                  caps.wPeriodMin, caps.wPeriodMax);
 784         mdate_selected = mdate_multimedia;
 785     }
 786 #endif
 787     else
 788     if (!strcmp (name, "perf"))
 789     {
 790         msg_Dbg (obj, "using performance counters as clock source");
 791         if (!QueryPerformanceFrequency (&clk.perf.freq))
 792             abort ();
 793         msg_Dbg (obj, " frequency: %llu Hz", clk.perf.freq.QuadPart);
 794         mdate_selected = mdate_perf;
 795     }
 796     else
 797     if (!strcmp (name, "wall"))
 798     {
 799         msg_Dbg (obj, "using system time as clock source");
 800         mdate_selected = mdate_wall;
 801     }
 802     else
 803     {
 804         msg_Err (obj, "invalid clock source \"%s\"", name);
 805         abort ();
 806     }
 807     LeaveCriticalSection (&clock_lock);
 808     free (str);
 809 }
 810
 811 #define xstrdup(str) (strdup(str) ?: (abort(), NULL))
 812
 813 size_t EnumClockSource (vlc_object_t *obj, const char *var,
 814                         char ***vp, char ***np)
 815 {
 816     const size_t max = 6;
 817     char **values = xmalloc (sizeof (*values) * max);
 818     char **names = xmalloc (sizeof (*names) * max);
 819     size_t n = 0;
 820
 821 #if (_WIN32_WINNT < 0x0601)
 822     DWORD version = LOWORD(GetVersion());
 823     version = (LOBYTE(version) << 8) | (HIBYTE(version) << 0);
 824 #endif
 825
 826     values[n] = xstrdup ("");
 827     names[n] = xstrdup (_("Auto"));
 828     n++;
 829 #if (_WIN32_WINNT < 0x0601)
 830     if (version >= 0x0601)
 831 #endif
 832     {
 833         values[n] = xstrdup ("interrupt");
 834         names[n] = xstrdup ("Interrupt time");
 835         n++;
 836     }
 837 #if (_WIN32_WINNT < 0x0600)
 838     if (version >= 0x0600)
 839 #endif
 840     {
 841         values[n] = xstrdup ("tick");
 842         names[n] = xstrdup ("Windows time");
 843         n++;
 844     }
 845 #if !VLC_WINSTORE_APP
 846     values[n] = xstrdup ("multimedia");
 847     names[n] = xstrdup ("Multimedia timers");
 848     n++;
 849 #endif
 850     values[n] = xstrdup ("perf");
 851     names[n] = xstrdup ("Performance counters");
 852     n++;
 853     values[n] = xstrdup ("wall");
 854     names[n] = xstrdup ("System time (DANGEROUS!)");
 855     n++;
 856
 857     *vp = values;
 858     *np = names;
 859     (void) obj; (void) var;
 860     return n;
 861 }
 862
 863
 864 /*** Timers ***/
 865 struct vlc_timer
 866 {
 867     HANDLE handle;
 868     void (*func) (void *);
 869     void *data;
 870 };
 871
 872 static void CALLBACK vlc_timer_do (void *val, BOOLEAN timeout)
 873 {
 874     struct vlc_timer *timer = val;
 875
 876     assert (timeout);
 877     timer->func (timer->data);
 878 }
 879
 880 int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
 881 {
 882     struct vlc_timer *timer = malloc (sizeof (*timer));
 883
 884     if (timer == NULL)
 885         return ENOMEM;
 886     timer->func = func;
 887     timer->data = data;
 888     timer->handle = INVALID_HANDLE_VALUE;
 889     *id = timer;
 890     return 0;
 891 }
 892
 893 void vlc_timer_destroy (vlc_timer_t timer)
 894 {
 895     if (timer->handle != INVALID_HANDLE_VALUE)
 896         DeleteTimerQueueTimer (NULL, timer->handle, INVALID_HANDLE_VALUE);
 897     free (timer);
 898 }
 899
 900 void vlc_timer_schedule (vlc_timer_t timer, bool absolute,
 901                          mtime_t value, mtime_t interval)
 902 {
 903     if (timer->handle != INVALID_HANDLE_VALUE)
 904     {
 905         DeleteTimerQueueTimer (NULL, timer->handle, NULL);
 906         timer->handle = INVALID_HANDLE_VALUE;
 907     }
 908     if (value == 0)
 909         return; /* Disarm */
 910
 911     if (absolute)
 912         value -= mdate ();
 913     value = (value + 999) / 1000;
 914     interval = (interval + 999) / 1000;
 915
 916     if (!CreateTimerQueueTimer (&timer->handle, NULL, vlc_timer_do, timer,
 917                                 value, interval, WT_EXECUTEDEFAULT))
 918         abort ();
 919 }
 920
 921 unsigned vlc_timer_getoverrun (vlc_timer_t timer)
 922 {
 923     (void)timer;
 924     return 0;
 925 }
 926
 927
 928 /*** CPU ***/
 929 unsigned vlc_GetCPUCount (void)
 930 {
 931     SYSTEM_INFO systemInfo;
 932
 933     GetNativeSystemInfo(&systemInfo);
 934
 935     return systemInfo.dwNumberOfProcessors;
 936 }
 937
 938
 939 /*** Initialization ***/
 940 void vlc_threads_setup (libvlc_int_t *p_libvlc)
 941 {
 942     SelectClockSource (VLC_OBJECT(p_libvlc));
 943 }
 944
 945 extern vlc_rwlock_t config_lock;
 946 BOOL WINAPI DllMain (HINSTANCE, DWORD, LPVOID);
 947
 948 BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
 949 {
 950     (void) hinstDll;
 951     (void) lpvReserved;
 952
 953     switch (fdwReason)
 954     {
 955         case DLL_PROCESS_ATTACH:
 956             InitializeCriticalSection (&clock_lock);
 957             vlc_mutex_init (&super_mutex);
 958             vlc_cond_init (&super_variable);
 959             vlc_threadvar_create (&thread_key, NULL);
 960             vlc_rwlock_init (&config_lock);
 961             vlc_CPU_init ();
 962             break;
 963
 964         case DLL_PROCESS_DETACH:
 965             vlc_rwlock_destroy (&config_lock);
 966             vlc_threadvar_delete (&thread_key);
 967             vlc_cond_destroy (&super_variable);
 968             vlc_mutex_destroy (&super_mutex);
 969             DeleteCriticalSection (&clock_lock);
 970             break;
 971     }
 972     return TRUE;
 973 }