1/* 2 * Copyright (C) 2010-2011 x264 project 3 * 4 * Authors: Steven Walters <kemuri9@gmail.com> 5 * Pegasys Inc. <http://www.pegasys-inc.com> 6 * 7 * This file is part of FFmpeg. 8 * 9 * FFmpeg is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * FFmpeg is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with FFmpeg; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 22 */ 23 24/** 25 * @file 26 * w32threads to pthreads wrapper 27 */ 28 29#ifndef FFMPEG_COMPAT_W32PTHREADS_H 30#define FFMPEG_COMPAT_W32PTHREADS_H 31 32/* Build up a pthread-like API using underlying Windows API. Have only static 33 * methods so as to not conflict with a potentially linked in pthread-win32 34 * library. 35 * As most functions here are used without checking return values, 36 * only implement return values as necessary. */ 37 38#define WIN32_LEAN_AND_MEAN 39#include <windows.h> 40#include <process.h> 41 42#include "libavutil/common.h" 43#include "libavutil/internal.h" 44#include "libavutil/mem.h" 45 46typedef struct pthread_t { 47 void *handle; 48 void *(*func)(void* arg); 49 void *arg; 50 void *ret; 51} pthread_t; 52 53/* the conditional variable api for windows 6.0+ uses critical sections and 54 * not mutexes */ 55typedef CRITICAL_SECTION pthread_mutex_t; 56 57/* This is the CONDITIONAL_VARIABLE typedef for using Window's native 58 * conditional variables on kernels 6.0+. 59 * MinGW does not currently have this typedef. */ 60typedef struct pthread_cond_t { 61 void *ptr; 62} pthread_cond_t; 63 64/* function pointers to conditional variable API on windows 6.0+ kernels */ 65#if _WIN32_WINNT < 0x0600 66static void (WINAPI *cond_broadcast)(pthread_cond_t *cond); 67static void (WINAPI *cond_init)(pthread_cond_t *cond); 68static void (WINAPI *cond_signal)(pthread_cond_t *cond); 69static BOOL (WINAPI *cond_wait)(pthread_cond_t *cond, pthread_mutex_t *mutex, 70 DWORD milliseconds); 71#else 72#define cond_init InitializeConditionVariable 73#define cond_broadcast WakeAllConditionVariable 74#define cond_signal WakeConditionVariable 75#define cond_wait SleepConditionVariableCS 76#endif 77 78static unsigned __stdcall attribute_align_arg win32thread_worker(void *arg) 79{ 80 pthread_t *h = arg; 81 h->ret = h->func(h->arg); 82 return 0; 83} 84 85static int pthread_create(pthread_t *thread, const void *unused_attr, 86 void *(*start_routine)(void*), void *arg) 87{ 88 thread->func = start_routine; 89 thread->arg = arg; 90 thread->handle = (void*)_beginthreadex(NULL, 0, win32thread_worker, thread, 91 0, NULL); 92 return !thread->handle; 93} 94 95static void pthread_join(pthread_t thread, void **value_ptr) 96{ 97 DWORD ret = WaitForSingleObject(thread.handle, INFINITE); 98 if (ret != WAIT_OBJECT_0) 99 return; 100 if (value_ptr) 101 *value_ptr = thread.ret; 102 CloseHandle(thread.handle); 103} 104 105static inline int pthread_mutex_init(pthread_mutex_t *m, void* attr) 106{ 107 InitializeCriticalSection(m); 108 return 0; 109} 110static inline int pthread_mutex_destroy(pthread_mutex_t *m) 111{ 112 DeleteCriticalSection(m); 113 return 0; 114} 115static inline int pthread_mutex_lock(pthread_mutex_t *m) 116{ 117 EnterCriticalSection(m); 118 return 0; 119} 120static inline int pthread_mutex_unlock(pthread_mutex_t *m) 121{ 122 LeaveCriticalSection(m); 123 return 0; 124} 125 126/* for pre-Windows 6.0 platforms we need to define and use our own condition 127 * variable and api */ 128typedef struct win32_cond_t { 129 pthread_mutex_t mtx_broadcast; 130 pthread_mutex_t mtx_waiter_count; 131 volatile int waiter_count; 132 HANDLE semaphore; 133 HANDLE waiters_done; 134 volatile int is_broadcast; 135} win32_cond_t; 136 137static int pthread_cond_init(pthread_cond_t *cond, const void *unused_attr) 138{ 139 win32_cond_t *win32_cond = NULL; 140 if (cond_init) { 141 cond_init(cond); 142 return 0; 143 } 144 145 /* non native condition variables */ 146 win32_cond = av_mallocz(sizeof(win32_cond_t)); 147 if (!win32_cond) 148 return ENOMEM; 149 cond->ptr = win32_cond; 150 win32_cond->semaphore = CreateSemaphore(NULL, 0, 0x7fffffff, NULL); 151 if (!win32_cond->semaphore) 152 return ENOMEM; 153 win32_cond->waiters_done = CreateEvent(NULL, TRUE, FALSE, NULL); 154 if (!win32_cond->waiters_done) 155 return ENOMEM; 156 157 pthread_mutex_init(&win32_cond->mtx_waiter_count, NULL); 158 pthread_mutex_init(&win32_cond->mtx_broadcast, NULL); 159 return 0; 160} 161 162static void pthread_cond_destroy(pthread_cond_t *cond) 163{ 164 win32_cond_t *win32_cond = cond->ptr; 165 /* native condition variables do not destroy */ 166 if (cond_init) 167 return; 168 169 /* non native condition variables */ 170 CloseHandle(win32_cond->semaphore); 171 CloseHandle(win32_cond->waiters_done); 172 pthread_mutex_destroy(&win32_cond->mtx_waiter_count); 173 pthread_mutex_destroy(&win32_cond->mtx_broadcast); 174 av_freep(&win32_cond); 175 cond->ptr = NULL; 176} 177 178static void pthread_cond_broadcast(pthread_cond_t *cond) 179{ 180 win32_cond_t *win32_cond = cond->ptr; 181 int have_waiter; 182 183 if (cond_broadcast) { 184 cond_broadcast(cond); 185 return; 186 } 187 188 /* non native condition variables */ 189 pthread_mutex_lock(&win32_cond->mtx_broadcast); 190 pthread_mutex_lock(&win32_cond->mtx_waiter_count); 191 have_waiter = 0; 192 193 if (win32_cond->waiter_count) { 194 win32_cond->is_broadcast = 1; 195 have_waiter = 1; 196 } 197 198 if (have_waiter) { 199 ReleaseSemaphore(win32_cond->semaphore, win32_cond->waiter_count, NULL); 200 pthread_mutex_unlock(&win32_cond->mtx_waiter_count); 201 WaitForSingleObject(win32_cond->waiters_done, INFINITE); 202 ResetEvent(win32_cond->waiters_done); 203 win32_cond->is_broadcast = 0; 204 } else 205 pthread_mutex_unlock(&win32_cond->mtx_waiter_count); 206 pthread_mutex_unlock(&win32_cond->mtx_broadcast); 207} 208 209static int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) 210{ 211 win32_cond_t *win32_cond = cond->ptr; 212 int last_waiter; 213 if (cond_wait) { 214 cond_wait(cond, mutex, INFINITE); 215 return 0; 216 } 217 218 /* non native condition variables */ 219 pthread_mutex_lock(&win32_cond->mtx_broadcast); 220 pthread_mutex_lock(&win32_cond->mtx_waiter_count); 221 win32_cond->waiter_count++; 222 pthread_mutex_unlock(&win32_cond->mtx_waiter_count); 223 pthread_mutex_unlock(&win32_cond->mtx_broadcast); 224 225 // unlock the external mutex 226 pthread_mutex_unlock(mutex); 227 WaitForSingleObject(win32_cond->semaphore, INFINITE); 228 229 pthread_mutex_lock(&win32_cond->mtx_waiter_count); 230 win32_cond->waiter_count--; 231 last_waiter = !win32_cond->waiter_count || !win32_cond->is_broadcast; 232 pthread_mutex_unlock(&win32_cond->mtx_waiter_count); 233 234 if (last_waiter) 235 SetEvent(win32_cond->waiters_done); 236 237 // lock the external mutex 238 return pthread_mutex_lock(mutex); 239} 240 241static void pthread_cond_signal(pthread_cond_t *cond) 242{ 243 win32_cond_t *win32_cond = cond->ptr; 244 int have_waiter; 245 if (cond_signal) { 246 cond_signal(cond); 247 return; 248 } 249 250 pthread_mutex_lock(&win32_cond->mtx_broadcast); 251 252 /* non-native condition variables */ 253 pthread_mutex_lock(&win32_cond->mtx_waiter_count); 254 have_waiter = win32_cond->waiter_count; 255 pthread_mutex_unlock(&win32_cond->mtx_waiter_count); 256 257 if (have_waiter) { 258 ReleaseSemaphore(win32_cond->semaphore, 1, NULL); 259 WaitForSingleObject(win32_cond->waiters_done, INFINITE); 260 ResetEvent(win32_cond->waiters_done); 261 } 262 263 pthread_mutex_unlock(&win32_cond->mtx_broadcast); 264} 265 266static void w32thread_init(void) 267{ 268#if _WIN32_WINNT < 0x0600 269 HANDLE kernel_dll = GetModuleHandle(TEXT("kernel32.dll")); 270 /* if one is available, then they should all be available */ 271 cond_init = 272 (void*)GetProcAddress(kernel_dll, "InitializeConditionVariable"); 273 cond_broadcast = 274 (void*)GetProcAddress(kernel_dll, "WakeAllConditionVariable"); 275 cond_signal = 276 (void*)GetProcAddress(kernel_dll, "WakeConditionVariable"); 277 cond_wait = 278 (void*)GetProcAddress(kernel_dll, "SleepConditionVariableCS"); 279#endif 280 281} 282 283#endif /* FFMPEG_COMPAT_W32PTHREADS_H */ 284