X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=compat%2Fw32pthreads.h;h=2fe2a5ab979ff676d1e7dba4a360306dde29a0f0;hb=407ac22322e5ce67996ec54ef619cafa4c9ceb78;hp=7f4e6c9ba41e96fb99c839d58e52563c78848eee;hpb=428b0578c64241fc677fed7083cc8fe65e10f32e;p=ffmpeg diff --git a/compat/w32pthreads.h b/compat/w32pthreads.h index 7f4e6c9ba41..2fe2a5ab979 100644 --- a/compat/w32pthreads.h +++ b/compat/w32pthreads.h @@ -39,6 +39,12 @@ #include #include +#if _WIN32_WINNT < 0x0600 && defined(__MINGW32__) +#undef MemoryBarrier +#define MemoryBarrier __sync_synchronize +#endif + +#include "libavutil/attributes.h" #include "libavutil/internal.h" #include "libavutil/mem.h" @@ -53,48 +59,30 @@ typedef struct pthread_t { * not mutexes */ typedef CRITICAL_SECTION pthread_mutex_t; -/* This is the CONDITIONAL_VARIABLE typedef for using Window's native - * conditional variables on kernels 6.0+. - * MinGW does not currently have this typedef. */ +/* This is the CONDITION_VARIABLE typedef for using Windows' native + * conditional variables on kernels 6.0+. */ +#if HAVE_CONDITION_VARIABLE_PTR +typedef CONDITION_VARIABLE pthread_cond_t; +#else typedef struct pthread_cond_t { - void *ptr; + void *Ptr; } pthread_cond_t; +#endif -/* function pointers to conditional variable API on windows 6.0+ kernels */ -#if _WIN32_WINNT < 0x0600 -static void (WINAPI *cond_broadcast)(pthread_cond_t *cond); -static void (WINAPI *cond_init)(pthread_cond_t *cond); -static void (WINAPI *cond_signal)(pthread_cond_t *cond); -static BOOL (WINAPI *cond_wait)(pthread_cond_t *cond, pthread_mutex_t *mutex, - DWORD milliseconds); -#else -#define cond_init InitializeConditionVariable -#define cond_broadcast WakeAllConditionVariable -#define cond_signal WakeConditionVariable -#define cond_wait SleepConditionVariableCS - -#define CreateEvent(a, reset, init, name) \ - CreateEventEx(a, name, \ - (reset ? CREATE_EVENT_MANUAL_RESET : 0) | \ - (init ? CREATE_EVENT_INITIAL_SET : 0), \ - EVENT_ALL_ACCESS) -// CreateSemaphoreExA seems to be desktop-only, but as long as we don't -// use named semaphores, it doesn't matter if we use the W version. -#define CreateSemaphore(a, b, c, d) \ - CreateSemaphoreExW(a, b, c, d, 0, SEMAPHORE_ALL_ACCESS) +#if _WIN32_WINNT >= 0x0600 #define InitializeCriticalSection(x) InitializeCriticalSectionEx(x, 0, 0) #define WaitForSingleObject(a, b) WaitForSingleObjectEx(a, b, FALSE) #endif -static unsigned __stdcall attribute_align_arg win32thread_worker(void *arg) +static av_unused unsigned __stdcall attribute_align_arg win32thread_worker(void *arg) { pthread_t *h = arg; h->ret = h->func(h->arg); return 0; } -static int pthread_create(pthread_t *thread, const void *unused_attr, - void *(*start_routine)(void*), void *arg) +static av_unused int pthread_create(pthread_t *thread, const void *unused_attr, + void *(*start_routine)(void*), void *arg) { thread->func = start_routine; thread->arg = arg; @@ -103,7 +91,7 @@ static int pthread_create(pthread_t *thread, const void *unused_attr, return !thread->handle; } -static void pthread_join(pthread_t thread, void **value_ptr) +static av_unused void pthread_join(pthread_t thread, void **value_ptr) { DWORD ret = WaitForSingleObject(thread.handle, INFINITE); if (ret != WAIT_OBJECT_0) @@ -134,8 +122,113 @@ static inline int pthread_mutex_unlock(pthread_mutex_t *m) return 0; } +#if _WIN32_WINNT >= 0x0600 + +typedef INIT_ONCE pthread_once_t; +#define PTHREAD_ONCE_INIT INIT_ONCE_STATIC_INIT + +static av_unused int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) +{ + BOOL pending = FALSE; + InitOnceBeginInitialize(once_control, 0, &pending, NULL); + if (pending) + init_routine(); + InitOnceComplete(once_control, 0, NULL); + return 0; +} + +static inline void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) +{ + InitializeConditionVariable(cond); +} + +/* native condition variables do not destroy */ +static inline void pthread_cond_destroy(pthread_cond_t *cond) +{ + return; +} + +static inline void pthread_cond_broadcast(pthread_cond_t *cond) +{ + WakeAllConditionVariable(cond); +} + +static inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) +{ + SleepConditionVariableCS(cond, mutex, INFINITE); + return 0; +} + +static inline void pthread_cond_signal(pthread_cond_t *cond) +{ + WakeConditionVariable(cond); +} + +#else // _WIN32_WINNT < 0x0600 + +/* atomic init state of dynamically loaded functions */ +static LONG w32thread_init_state = 0; +static av_unused void w32thread_init(void); + +/* for pre-Windows 6.0 platforms, define INIT_ONCE struct, + * compatible to the one used in the native API */ + +typedef union pthread_once_t { + void * Ptr; ///< For the Windows 6.0+ native functions + LONG state; ///< For the pre-Windows 6.0 compat code +} pthread_once_t; + +#define PTHREAD_ONCE_INIT {0} + +/* function pointers to init once API on windows 6.0+ kernels */ +static BOOL (WINAPI *initonce_begin)(pthread_once_t *lpInitOnce, DWORD dwFlags, BOOL *fPending, void **lpContext); +static BOOL (WINAPI *initonce_complete)(pthread_once_t *lpInitOnce, DWORD dwFlags, void *lpContext); + +/* pre-Windows 6.0 compat using a spin-lock */ +static inline void w32thread_once_fallback(LONG volatile *state, void (*init_routine)(void)) +{ + switch (InterlockedCompareExchange(state, 1, 0)) { + /* Initial run */ + case 0: + init_routine(); + InterlockedExchange(state, 2); + break; + /* Another thread is running init */ + case 1: + while (1) { + MemoryBarrier(); + if (*state == 2) + break; + Sleep(0); + } + break; + /* Initialization complete */ + case 2: + break; + } +} + +static av_unused int pthread_once(pthread_once_t *once_control, void (*init_routine)(void)) +{ + w32thread_once_fallback(&w32thread_init_state, w32thread_init); + + /* Use native functions on Windows 6.0+ */ + if (initonce_begin && initonce_complete) { + BOOL pending = FALSE; + initonce_begin(once_control, 0, &pending, NULL); + if (pending) + init_routine(); + initonce_complete(once_control, 0, NULL); + return 0; + } + + w32thread_once_fallback(&once_control->state, init_routine); + return 0; +} + /* for pre-Windows 6.0 platforms we need to define and use our own condition * variable and api */ + typedef struct win32_cond_t { pthread_mutex_t mtx_broadcast; pthread_mutex_t mtx_waiter_count; @@ -145,9 +238,19 @@ typedef struct win32_cond_t { volatile int is_broadcast; } win32_cond_t; -static void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) +/* function pointers to conditional variable API on windows 6.0+ kernels */ +static void (WINAPI *cond_broadcast)(pthread_cond_t *cond); +static void (WINAPI *cond_init)(pthread_cond_t *cond); +static void (WINAPI *cond_signal)(pthread_cond_t *cond); +static BOOL (WINAPI *cond_wait)(pthread_cond_t *cond, pthread_mutex_t *mutex, + DWORD milliseconds); + +static av_unused void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) { win32_cond_t *win32_cond = NULL; + + w32thread_once_fallback(&w32thread_init_state, w32thread_init); + if (cond_init) { cond_init(cond); return; @@ -157,7 +260,7 @@ static void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) win32_cond = av_mallocz(sizeof(win32_cond_t)); if (!win32_cond) return; - cond->ptr = win32_cond; + cond->Ptr = win32_cond; win32_cond->semaphore = CreateSemaphore(NULL, 0, 0x7fffffff, NULL); if (!win32_cond->semaphore) return; @@ -169,9 +272,9 @@ static void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) pthread_mutex_init(&win32_cond->mtx_broadcast, NULL); } -static void pthread_cond_destroy(pthread_cond_t *cond) +static av_unused void pthread_cond_destroy(pthread_cond_t *cond) { - win32_cond_t *win32_cond = cond->ptr; + win32_cond_t *win32_cond = cond->Ptr; /* native condition variables do not destroy */ if (cond_init) return; @@ -182,12 +285,12 @@ static void pthread_cond_destroy(pthread_cond_t *cond) pthread_mutex_destroy(&win32_cond->mtx_waiter_count); pthread_mutex_destroy(&win32_cond->mtx_broadcast); av_freep(&win32_cond); - cond->ptr = NULL; + cond->Ptr = NULL; } -static void pthread_cond_broadcast(pthread_cond_t *cond) +static av_unused void pthread_cond_broadcast(pthread_cond_t *cond) { - win32_cond_t *win32_cond = cond->ptr; + win32_cond_t *win32_cond = cond->Ptr; int have_waiter; if (cond_broadcast) { @@ -216,9 +319,9 @@ static void pthread_cond_broadcast(pthread_cond_t *cond) pthread_mutex_unlock(&win32_cond->mtx_broadcast); } -static int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) +static av_unused int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) { - win32_cond_t *win32_cond = cond->ptr; + win32_cond_t *win32_cond = cond->Ptr; int last_waiter; if (cond_wait) { cond_wait(cond, mutex, INFINITE); @@ -248,9 +351,9 @@ static int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) return pthread_mutex_lock(mutex); } -static void pthread_cond_signal(pthread_cond_t *cond) +static av_unused void pthread_cond_signal(pthread_cond_t *cond) { - win32_cond_t *win32_cond = cond->ptr; + win32_cond_t *win32_cond = cond->Ptr; int have_waiter; if (cond_signal) { cond_signal(cond); @@ -272,8 +375,9 @@ static void pthread_cond_signal(pthread_cond_t *cond) pthread_mutex_unlock(&win32_cond->mtx_broadcast); } +#endif -static void w32thread_init(void) +static av_unused void w32thread_init(void) { #if _WIN32_WINNT < 0x0600 HANDLE kernel_dll = GetModuleHandle(TEXT("kernel32.dll")); @@ -286,6 +390,10 @@ static void w32thread_init(void) (void*)GetProcAddress(kernel_dll, "WakeConditionVariable"); cond_wait = (void*)GetProcAddress(kernel_dll, "SleepConditionVariableCS"); + initonce_begin = + (void*)GetProcAddress(kernel_dll, "InitOnceBeginInitialize"); + initonce_complete = + (void*)GetProcAddress(kernel_dll, "InitOnceComplete"); #endif }