Remove useless timer parameter
[vlc.git] / src / misc / w32thread.c
1 /*****************************************************************************
2  * w32thread.c : Win32 back-end for LibVLC
3  *****************************************************************************
4  * Copyright (C) 1999-2009 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Jean-Marc Dressler <polux@via.ecp.fr>
8  *          Samuel Hocevar <sam@zoy.org>
9  *          Gildas Bazin <gbazin@netcourrier.com>
10  *          Clément Sténac
11  *          Rémi Denis-Courmont
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 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 General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, 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
38 static vlc_threadvar_t cancel_key;
39
40 /**
41  * Per-thread cancellation data
42  */
43 typedef struct vlc_cancel_t
44 {
45     vlc_cleanup_t *cleaners;
46 #ifdef UNDER_CE
47     HANDLE         cancel_event;
48 #endif
49     bool           killable;
50     bool           killed;
51 } vlc_cancel_t;
52
53 #ifndef UNDER_CE
54 # define VLC_CANCEL_INIT { NULL, true, false }
55 #else
56 # define VLC_CANCEL_INIT { NULL, NULL, true, false }
57 #endif
58
59 #ifdef UNDER_CE
60 static void CALLBACK vlc_cancel_self (ULONG_PTR dummy);
61
62 static DWORD vlc_cancelable_wait (DWORD count, const HANDLE *handles,
63                                   DWORD delay)
64 {
65     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
66     if (nfo == NULL)
67     {
68         /* Main thread - cannot be cancelled anyway */
69         return WaitForMultipleObjects (count, handles, FALSE, delay);
70     }
71     HANDLE new_handles[count + 1];
72     memcpy(new_handles, handles, count * sizeof(HANDLE));
73     new_handles[count] = nfo->cancel_event;
74     DWORD result = WaitForMultipleObjects (count + 1, new_handles, FALSE,
75                                            delay);
76     if (result == WAIT_OBJECT_0 + count)
77     {
78         vlc_cancel_self (NULL);
79         return WAIT_IO_COMPLETION;
80     }
81     else
82     {
83         return result;
84     }
85 }
86
87 DWORD SleepEx (DWORD dwMilliseconds, BOOL bAlertable)
88 {
89     if (bAlertable)
90     {
91         DWORD result = vlc_cancelable_wait (0, NULL, dwMilliseconds);
92         return (result == WAIT_TIMEOUT) ? 0 : WAIT_IO_COMPLETION;
93     }
94     else
95     {
96         Sleep(dwMilliseconds);
97         return 0;
98     }
99 }
100
101 DWORD WaitForSingleObjectEx (HANDLE hHandle, DWORD dwMilliseconds,
102                              BOOL bAlertable)
103 {
104     if (bAlertable)
105     {
106         /* The MSDN documentation specifies different return codes,
107          * but in practice they are the same. We just check that it
108          * remains so. */
109 #if WAIT_ABANDONED != WAIT_ABANDONED_0
110 # error Windows headers changed, code needs to be rewritten!
111 #endif
112         return vlc_cancelable_wait (1, &hHandle, dwMilliseconds);
113     }
114     else
115     {
116         return WaitForSingleObject (hHandle, dwMilliseconds);
117     }
118 }
119
120 DWORD WaitForMultipleObjectsEx (DWORD nCount, const HANDLE *lpHandles,
121                                 BOOL bWaitAll, DWORD dwMilliseconds,
122                                 BOOL bAlertable)
123 {
124     if (bAlertable)
125     {
126         /* We do not support the bWaitAll case */
127         assert (! bWaitAll);
128         return vlc_cancelable_wait (nCount, lpHandles, dwMilliseconds);
129     }
130     else
131     {
132         return WaitForMultipleObjects (nCount, lpHandles, bWaitAll,
133                                        dwMilliseconds);
134     }
135 }
136 #endif
137
138 static vlc_mutex_t super_mutex;
139
140 BOOL WINAPI DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
141 {
142     (void) hinstDll;
143     (void) lpvReserved;
144
145     switch (fdwReason)
146     {
147         case DLL_PROCESS_ATTACH:
148             vlc_mutex_init (&super_mutex);
149             vlc_threadvar_create (&cancel_key, free);
150             break;
151
152         case DLL_PROCESS_DETACH:
153             vlc_threadvar_delete( &cancel_key );
154             vlc_mutex_destroy (&super_mutex);
155             break;
156     }
157     return TRUE;
158 }
159
160 /*** Mutexes ***/
161 void vlc_mutex_init( vlc_mutex_t *p_mutex )
162 {
163     /* This creates a recursive mutex. This is OK as fast mutexes have
164      * no defined behavior in case of recursive locking. */
165     InitializeCriticalSection (&p_mutex->mutex);
166     p_mutex->initialized = 1;
167 }
168
169 void vlc_mutex_init_recursive( vlc_mutex_t *p_mutex )
170 {
171     InitializeCriticalSection( &p_mutex->mutex );
172     p_mutex->initialized = 1;
173 }
174
175
176 void vlc_mutex_destroy (vlc_mutex_t *p_mutex)
177 {
178     assert (InterlockedExchange (&p_mutex->initialized, -1) == 1);
179     DeleteCriticalSection (&p_mutex->mutex);
180 }
181
182 void vlc_mutex_lock (vlc_mutex_t *p_mutex)
183 {
184     if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
185     { /* ^^ We could also lock super_mutex all the time... sluggish */
186         assert (p_mutex != &super_mutex); /* this one cannot be static */
187
188         vlc_mutex_lock (&super_mutex);
189         if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
190             vlc_mutex_init (p_mutex);
191         /* FIXME: destroy the mutex some time... */
192         vlc_mutex_unlock (&super_mutex);
193     }
194     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
195     EnterCriticalSection (&p_mutex->mutex);
196 }
197
198 int vlc_mutex_trylock (vlc_mutex_t *p_mutex)
199 {
200     if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
201     { /* ^^ We could also lock super_mutex all the time... sluggish */
202         assert (p_mutex != &super_mutex); /* this one cannot be static */
203
204         vlc_mutex_lock (&super_mutex);
205         if (InterlockedCompareExchange (&p_mutex->initialized, 0, 0) == 0)
206             vlc_mutex_init (p_mutex);
207         /* FIXME: destroy the mutex some time... */
208         vlc_mutex_unlock (&super_mutex);
209     }
210     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
211     return TryEnterCriticalSection (&p_mutex->mutex) ? 0 : EBUSY;
212 }
213
214 void vlc_mutex_unlock (vlc_mutex_t *p_mutex)
215 {
216     assert (InterlockedExchange (&p_mutex->initialized, 1) == 1);
217     LeaveCriticalSection (&p_mutex->mutex);
218 }
219
220 /*** Condition variables ***/
221 void vlc_cond_init( vlc_cond_t *p_condvar )
222 {
223     /* Create a manual-reset event (manual reset is needed for broadcast). */
224     *p_condvar = CreateEvent (NULL, TRUE, FALSE, NULL);
225     if (!*p_condvar)
226         abort();
227 }
228
229 void vlc_cond_destroy (vlc_cond_t *p_condvar)
230 {
231     CloseHandle (*p_condvar);
232 }
233
234 void vlc_cond_signal (vlc_cond_t *p_condvar)
235 {
236     /* NOTE: This will cause a broadcast, that is wrong.
237      * This will also wake up the next waiting thread if no threads are yet
238      * waiting, which is also wrong. However both of these issues are allowed
239      * by the provision for spurious wakeups. Better have too many wakeups
240      * than too few (= deadlocks). */
241     SetEvent (*p_condvar);
242 }
243
244 void vlc_cond_broadcast (vlc_cond_t *p_condvar)
245 {
246     SetEvent (*p_condvar);
247 }
248
249 void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
250 {
251     DWORD result;
252
253     do
254     {
255         vlc_testcancel ();
256         LeaveCriticalSection (&p_mutex->mutex);
257         result = WaitForSingleObjectEx (*p_condvar, INFINITE, TRUE);
258         EnterCriticalSection (&p_mutex->mutex);
259     }
260     while (result == WAIT_IO_COMPLETION);
261
262     assert (result != WAIT_ABANDONED); /* another thread failed to cleanup! */
263     assert (result != WAIT_FAILED);
264     ResetEvent (*p_condvar);
265 }
266
267 int vlc_cond_timedwait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex,
268                         mtime_t deadline)
269 {
270     DWORD result;
271
272     do
273     {
274         vlc_testcancel ();
275
276         mtime_t total = (deadline - mdate ())/1000;
277         if( total < 0 )
278             total = 0;
279
280         DWORD delay = (total > 0x7fffffff) ? 0x7fffffff : total;
281         LeaveCriticalSection (&p_mutex->mutex);
282         result = WaitForSingleObjectEx (*p_condvar, delay, TRUE);
283         EnterCriticalSection (&p_mutex->mutex);
284     }
285     while (result == WAIT_IO_COMPLETION);
286
287     assert (result != WAIT_ABANDONED);
288     assert (result != WAIT_FAILED);
289     ResetEvent (*p_condvar);
290
291     return (result == WAIT_OBJECT_0) ? 0 : ETIMEDOUT;
292 }
293
294 /*** Thread-specific variables (TLS) ***/
295 int vlc_threadvar_create (vlc_threadvar_t *p_tls, void (*destr) (void *))
296 {
297 #warning FIXME: use destr() callback and stop leaking!
298     *p_tls = TlsAlloc();
299     return (*p_tls == TLS_OUT_OF_INDEXES) ? EAGAIN : 0;
300 }
301
302 void vlc_threadvar_delete (vlc_threadvar_t *p_tls)
303 {
304     TlsFree (*p_tls);
305 }
306
307 /**
308  * Sets a thread-local variable.
309  * @param key thread-local variable key (created with vlc_threadvar_create())
310  * @param value new value for the variable for the calling thread
311  * @return 0 on success, a system error code otherwise.
312  */
313 int vlc_threadvar_set (vlc_threadvar_t key, void *value)
314 {
315     return TlsSetValue (key, value) ? ENOMEM : 0;
316 }
317
318 /**
319  * Gets the value of a thread-local variable for the calling thread.
320  * This function cannot fail.
321  * @return the value associated with the given variable for the calling
322  * or NULL if there is no value.
323  */
324 void *vlc_threadvar_get (vlc_threadvar_t key)
325 {
326     return TlsGetValue (key);
327 }
328
329
330 /*** Threads ***/
331 static unsigned __stdcall vlc_entry (void *data)
332 {
333     vlc_cancel_t cancel_data = VLC_CANCEL_INIT;
334     vlc_thread_t self = data;
335 #ifdef UNDER_CE
336     cancel_data.cancel_event = self->cancel_event;
337 #endif
338
339     vlc_threadvar_set (cancel_key, &cancel_data);
340     self->data = self->entry (self->data);
341     return 0;
342 }
343
344 int vlc_clone (vlc_thread_t *p_handle, void * (*entry) (void *), void *data,
345                int priority)
346 {
347     /* When using the MSVCRT C library you have to use the _beginthreadex
348      * function instead of CreateThread, otherwise you'll end up with
349      * memory leaks and the signal functions not working (see Microsoft
350      * Knowledge Base, article 104641) */
351     HANDLE hThread;
352     vlc_thread_t th = malloc (sizeof (*th));
353
354     if (th == NULL)
355         return ENOMEM;
356
357     th->data = data;
358     th->entry = entry;
359 #if defined( UNDER_CE )
360     th->cancel_event = CreateEvent (NULL, FALSE, FALSE, NULL);
361     if (th->cancel_event == NULL)
362     {
363         free(th);
364         return errno;
365     }
366     hThread = CreateThread (NULL, 128*1024, vlc_entry, th, CREATE_SUSPENDED, NULL);
367 #else
368     hThread = (HANDLE)(uintptr_t)
369         _beginthreadex (NULL, 0, vlc_entry, th, CREATE_SUSPENDED, NULL);
370 #endif
371
372     if (hThread)
373     {
374 #ifndef UNDER_CE
375         /* Thread closes the handle when exiting, duplicate it here
376          * to be on the safe side when joining. */
377         if (!DuplicateHandle (GetCurrentProcess (), hThread,
378                               GetCurrentProcess (), &th->handle, 0, FALSE,
379                               DUPLICATE_SAME_ACCESS))
380         {
381             CloseHandle (hThread);
382             free (th);
383             return ENOMEM;
384         }
385 #else
386         th->handle = hThread;
387 #endif
388
389         ResumeThread (hThread);
390         if (priority)
391             SetThreadPriority (hThread, priority);
392
393         *p_handle = th;
394         return 0;
395     }
396     free (th);
397     return errno;
398 }
399
400 void vlc_join (vlc_thread_t handle, void **result)
401 {
402     do
403         vlc_testcancel ();
404     while (WaitForSingleObjectEx (handle->handle, INFINITE, TRUE)
405                                                         == WAIT_IO_COMPLETION);
406
407     CloseHandle (handle->handle);
408     if (result)
409         *result = handle->data;
410 #ifdef UNDER_CE
411     CloseHandle (handle->cancel_event);
412 #endif
413     free (handle);
414 }
415
416
417 /*** Thread cancellation ***/
418
419 /* APC procedure for thread cancellation */
420 static void CALLBACK vlc_cancel_self (ULONG_PTR dummy)
421 {
422     (void)dummy;
423     vlc_control_cancel (VLC_DO_CANCEL);
424 }
425
426 void vlc_cancel (vlc_thread_t thread_id)
427 {
428 #ifndef UNDER_CE
429     QueueUserAPC (vlc_cancel_self, thread_id->handle, 0);
430 #else
431     SetEvent (thread_id->cancel_event);
432 #endif
433 }
434
435 int vlc_savecancel (void)
436 {
437     int state;
438
439     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
440     if (nfo == NULL)
441         return false; /* Main thread - cannot be cancelled anyway */
442
443     state = nfo->killable;
444     nfo->killable = false;
445     return state;
446 }
447
448 void vlc_restorecancel (int state)
449 {
450     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
451     assert (state == false || state == true);
452
453     if (nfo == NULL)
454         return; /* Main thread - cannot be cancelled anyway */
455
456     assert (!nfo->killable);
457     nfo->killable = state != 0;
458 }
459
460 void vlc_testcancel (void)
461 {
462     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
463     if (nfo == NULL)
464         return; /* Main thread - cannot be cancelled anyway */
465
466     if (nfo->killable && nfo->killed)
467     {
468         for (vlc_cleanup_t *p = nfo->cleaners; p != NULL; p = p->next)
469              p->proc (p->data);
470 #ifndef UNDER_CE
471         _endthread ();
472 #else
473         ExitThread(0);
474 #endif
475     }
476 }
477
478 void vlc_control_cancel (int cmd, ...)
479 {
480     /* NOTE: This function only modifies thread-specific data, so there is no
481      * need to lock anything. */
482     va_list ap;
483
484     vlc_cancel_t *nfo = vlc_threadvar_get (cancel_key);
485     if (nfo == NULL)
486         return; /* Main thread - cannot be cancelled anyway */
487
488     va_start (ap, cmd);
489     switch (cmd)
490     {
491         case VLC_DO_CANCEL:
492             nfo->killed = true;
493             break;
494
495         case VLC_CLEANUP_PUSH:
496         {
497             /* cleaner is a pointer to the caller stack, no need to allocate
498              * and copy anything. As a nice side effect, this cannot fail. */
499             vlc_cleanup_t *cleaner = va_arg (ap, vlc_cleanup_t *);
500             cleaner->next = nfo->cleaners;
501             nfo->cleaners = cleaner;
502             break;
503         }
504
505         case VLC_CLEANUP_POP:
506         {
507             nfo->cleaners = nfo->cleaners->next;
508             break;
509         }
510     }
511     va_end (ap);
512 }
513
514
515 /*** Timers ***/
516 static void CALLBACK vlc_timer_do (void *val, BOOLEAN timeout)
517 {
518     vlc_timer_t *id = val;
519
520     assert (timeout);
521     if (TryEnterCriticalSection (&id->serializer))
522     {
523         id->overrun = InterlockedExchange (&id->counter, 0);
524         id->func (id->data);
525         LeaveCriticalSection (&id->serializer);
526     }
527     else /* Overrun */
528         InterlockedIncrement (&id->counter);
529 }
530
531 int vlc_timer_create (vlc_timer_t *id, void (*func) (void *), void *data)
532 {
533     id->func = func;
534     id->data = data;
535     id->overrun = 0;
536     id->handle = INVALID_HANDLE_VALUE;
537     InitializeCriticalSection (&id->serializer);
538     return 0;
539 }
540
541 void vlc_timer_destroy (vlc_timer_t *id)
542 {
543     if (id->handle != INVALID_HANDLE_VALUE)
544         DeleteTimerQueueTimer (NULL, id->handle, NULL);
545     DeleteCriticalSection (&id->serializer);
546 }
547
548 void vlc_timer_schedule (vlc_timer_t *id, bool absolute,
549                          mtime_t value, mtime_t interval)
550 {
551     if (id->handle != INVALID_HANDLE_VALUE)
552     {
553         DeleteTimerQueueTimer (NULL, id->handle, NULL);
554         id->handle = INVALID_HANDLE_VALUE;
555     }
556     if (value == 0)
557         return; /* Disarm */
558
559     if (absolute)
560         value -= mdate ();
561     value = (value + 999) / 1000;
562     interval = (interval + 999) / 1000;
563     if (!CreateTimerQueueTimer (&id->handle, NULL, vlc_timer_do, id, value,
564                                 interval, WT_EXECUTEDEFAULT))
565         abort ();
566 }
567
568 unsigned vlc_timer_getoverrun (const vlc_timer_t *id)
569 {
570     return id->overrun;
571 }