+#elif defined( WIN32 )
+ /* Create a manual-reset event (manual reset is needed for broadcast). */
+ *p_condvar = CreateEvent( NULL, TRUE, FALSE, NULL );
+ return *p_condvar ? 0 : ENOMEM;
+
+#endif
+}
+
+/**
+ * Destroys a condition variable. No threads shall be waiting or signaling the
+ * condition.
+ * @param p_condvar condition variable to destroy
+ */
+void vlc_cond_destroy (vlc_cond_t *p_condvar)
+{
+#if defined( LIBVLC_USE_PTHREAD )
+ int val = pthread_cond_destroy( p_condvar );
+ VLC_THREAD_ASSERT ("destroying condition");
+
+#elif defined( WIN32 )
+ CloseHandle( *p_condvar );
+
+#endif
+}
+
+/**
+ * Wakes up one thread waiting on a condition variable, if any.
+ * @param p_condvar condition variable
+ */
+void vlc_cond_signal (vlc_cond_t *p_condvar)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_signal( p_condvar );
+ VLC_THREAD_ASSERT ("signaling condition variable");
+
+#elif defined( WIN32 )
+ /* NOTE: This will cause a broadcast, that is wrong.
+ * This will also wake up the next waiting thread if no thread are yet
+ * waiting, which is also wrong. However both of these issues are allowed
+ * by the provision for spurious wakeups. Better have too many wakeups
+ * than too few (= deadlocks). */
+ SetEvent (*p_condvar);
+
+#endif
+}
+
+/**
+ * Wakes up all threads (if any) waiting on a condition variable.
+ * @param p_cond condition variable
+ */
+void vlc_cond_broadcast (vlc_cond_t *p_condvar)
+{
+#if defined (LIBVLC_USE_PTHREAD)
+ pthread_cond_broadcast (p_condvar);
+
+#elif defined (WIN32)
+ SetEvent (*p_condvar);
+
+#endif
+}
+
+#ifdef UNDER_CE
+# warning FIXME
+# define WaitForMultipleObjectsEx(a,b,c) WaitForMultipleObjects(a,b)
+#endif
+
+/**
+ * Waits for a condition variable. The calling thread will be suspended until
+ * another thread calls vlc_cond_signal() or vlc_cond_broadcast() on the same
+ * condition variable, the thread is cancelled with vlc_cancel(), or the
+ * system causes a "spurious" unsolicited wake-up.
+ *
+ * A mutex is needed to wait on a condition variable. It must <b>not</b> be
+ * a recursive mutex. Although it is possible to use the same mutex for
+ * multiple condition, it is not valid to use different mutexes for the same
+ * condition variable at the same time from different threads.
+ *
+ * In case of thread cancellation, the mutex is always locked before
+ * cancellation proceeds.
+ *
+ * The canonical way to use a condition variable to wait for event foobar is:
+ @code
+ vlc_mutex_lock (&lock);
+ mutex_cleanup_push (&lock); // release the mutex in case of cancellation
+
+ while (!foobar)
+ vlc_cond_wait (&wait, &lock);
+
+ --- foobar is now true, do something about it here --
+
+ vlc_cleanup_run (); // release the mutex
+ @endcode
+ *
+ * @param p_condvar condition variable to wait on
+ * @param p_mutex mutex which is unlocked while waiting,
+ * then locked again when waking up.
+ * @param deadline <b>absolute</b> timeout
+ *
+ * @return 0 if the condition was signaled, an error code in case of timeout.
+ */
+void vlc_cond_wait (vlc_cond_t *p_condvar, vlc_mutex_t *p_mutex)
+{
+#if defined(LIBVLC_USE_PTHREAD)
+ int val = pthread_cond_wait( p_condvar, p_mutex );
+ VLC_THREAD_ASSERT ("waiting on condition");
+
+#elif defined( WIN32 )
+ DWORD result;