OLD | NEW |
(Empty) | |
| 1 // Copyright 2013 Google Inc. All Rights Reserved. |
| 2 // |
| 3 // Use of this source code is governed by a BSD-style license |
| 4 // that can be found in the COPYING file in the root of the source |
| 5 // tree. An additional intellectual property rights grant can be found |
| 6 // in the file PATENTS. All contributing project authors may |
| 7 // be found in the AUTHORS file in the root of the source tree. |
| 8 // ----------------------------------------------------------------------------- |
| 9 // |
| 10 // Multi-threaded worker |
| 11 // |
| 12 // Original source: |
| 13 // http://git.chromium.org/webm/libwebp.git |
| 14 // 100644 blob 7bd451b124ae3b81596abfbcc823e3cb129d3a38 src/utils/thread.h |
| 15 |
| 16 #ifndef VP9_DECODER_VP9_THREAD_H_ |
| 17 #define VP9_DECODER_VP9_THREAD_H_ |
| 18 |
| 19 #include "./vpx_config.h" |
| 20 |
| 21 #ifdef __cplusplus |
| 22 extern "C" { |
| 23 #endif |
| 24 |
| 25 #if CONFIG_MULTITHREAD |
| 26 |
| 27 #if defined(_WIN32) |
| 28 #include <errno.h> // NOLINT |
| 29 #include <process.h> // NOLINT |
| 30 #include <windows.h> // NOLINT |
| 31 typedef HANDLE pthread_t; |
| 32 typedef CRITICAL_SECTION pthread_mutex_t; |
| 33 typedef struct { |
| 34 HANDLE waiting_sem_; |
| 35 HANDLE received_sem_; |
| 36 HANDLE signal_event_; |
| 37 } pthread_cond_t; |
| 38 |
| 39 //------------------------------------------------------------------------------ |
| 40 // simplistic pthread emulation layer |
| 41 |
| 42 // _beginthreadex requires __stdcall |
| 43 #define THREADFN unsigned int __stdcall |
| 44 #define THREAD_RETURN(val) (unsigned int)((DWORD_PTR)val) |
| 45 |
| 46 static INLINE int pthread_create(pthread_t* const thread, const void* attr, |
| 47 unsigned int (__stdcall *start)(void*), |
| 48 void* arg) { |
| 49 (void)attr; |
| 50 *thread = (pthread_t)_beginthreadex(NULL, /* void *security */ |
| 51 0, /* unsigned stack_size */ |
| 52 start, |
| 53 arg, |
| 54 0, /* unsigned initflag */ |
| 55 NULL); /* unsigned *thrdaddr */ |
| 56 if (*thread == NULL) return 1; |
| 57 SetThreadPriority(*thread, THREAD_PRIORITY_ABOVE_NORMAL); |
| 58 return 0; |
| 59 } |
| 60 |
| 61 static INLINE int pthread_join(pthread_t thread, void** value_ptr) { |
| 62 (void)value_ptr; |
| 63 return (WaitForSingleObject(thread, INFINITE) != WAIT_OBJECT_0 || |
| 64 CloseHandle(thread) == 0); |
| 65 } |
| 66 |
| 67 // Mutex |
| 68 static INLINE int pthread_mutex_init(pthread_mutex_t *const mutex, |
| 69 void* mutexattr) { |
| 70 (void)mutexattr; |
| 71 InitializeCriticalSection(mutex); |
| 72 return 0; |
| 73 } |
| 74 |
| 75 static INLINE int pthread_mutex_trylock(pthread_mutex_t *const mutex) { |
| 76 return TryEnterCriticalSection(mutex) ? 0 : EBUSY; |
| 77 } |
| 78 |
| 79 static INLINE int pthread_mutex_lock(pthread_mutex_t *const mutex) { |
| 80 EnterCriticalSection(mutex); |
| 81 return 0; |
| 82 } |
| 83 |
| 84 static INLINE int pthread_mutex_unlock(pthread_mutex_t *const mutex) { |
| 85 LeaveCriticalSection(mutex); |
| 86 return 0; |
| 87 } |
| 88 |
| 89 static INLINE int pthread_mutex_destroy(pthread_mutex_t *const mutex) { |
| 90 DeleteCriticalSection(mutex); |
| 91 return 0; |
| 92 } |
| 93 |
| 94 // Condition |
| 95 static INLINE int pthread_cond_destroy(pthread_cond_t *const condition) { |
| 96 int ok = 1; |
| 97 ok &= (CloseHandle(condition->waiting_sem_) != 0); |
| 98 ok &= (CloseHandle(condition->received_sem_) != 0); |
| 99 ok &= (CloseHandle(condition->signal_event_) != 0); |
| 100 return !ok; |
| 101 } |
| 102 |
| 103 static INLINE int pthread_cond_init(pthread_cond_t *const condition, |
| 104 void* cond_attr) { |
| 105 (void)cond_attr; |
| 106 condition->waiting_sem_ = CreateSemaphore(NULL, 0, 1, NULL); |
| 107 condition->received_sem_ = CreateSemaphore(NULL, 0, 1, NULL); |
| 108 condition->signal_event_ = CreateEvent(NULL, FALSE, FALSE, NULL); |
| 109 if (condition->waiting_sem_ == NULL || |
| 110 condition->received_sem_ == NULL || |
| 111 condition->signal_event_ == NULL) { |
| 112 pthread_cond_destroy(condition); |
| 113 return 1; |
| 114 } |
| 115 return 0; |
| 116 } |
| 117 |
| 118 static INLINE int pthread_cond_signal(pthread_cond_t *const condition) { |
| 119 int ok = 1; |
| 120 if (WaitForSingleObject(condition->waiting_sem_, 0) == WAIT_OBJECT_0) { |
| 121 // a thread is waiting in pthread_cond_wait: allow it to be notified |
| 122 ok = SetEvent(condition->signal_event_); |
| 123 // wait until the event is consumed so the signaler cannot consume |
| 124 // the event via its own pthread_cond_wait. |
| 125 ok &= (WaitForSingleObject(condition->received_sem_, INFINITE) != |
| 126 WAIT_OBJECT_0); |
| 127 } |
| 128 return !ok; |
| 129 } |
| 130 |
| 131 static INLINE int pthread_cond_wait(pthread_cond_t *const condition, |
| 132 pthread_mutex_t *const mutex) { |
| 133 int ok; |
| 134 // note that there is a consumer available so the signal isn't dropped in |
| 135 // pthread_cond_signal |
| 136 if (!ReleaseSemaphore(condition->waiting_sem_, 1, NULL)) |
| 137 return 1; |
| 138 // now unlock the mutex so pthread_cond_signal may be issued |
| 139 pthread_mutex_unlock(mutex); |
| 140 ok = (WaitForSingleObject(condition->signal_event_, INFINITE) == |
| 141 WAIT_OBJECT_0); |
| 142 ok &= ReleaseSemaphore(condition->received_sem_, 1, NULL); |
| 143 pthread_mutex_lock(mutex); |
| 144 return !ok; |
| 145 } |
| 146 #else // _WIN32 |
| 147 #include <pthread.h> // NOLINT |
| 148 # define THREADFN void* |
| 149 # define THREAD_RETURN(val) val |
| 150 #endif |
| 151 |
| 152 #endif // CONFIG_MULTITHREAD |
| 153 |
| 154 // State of the worker thread object |
| 155 typedef enum { |
| 156 NOT_OK = 0, // object is unusable |
| 157 OK, // ready to work |
| 158 WORK // busy finishing the current task |
| 159 } VP9WorkerStatus; |
| 160 |
| 161 // Function to be called by the worker thread. Takes two opaque pointers as |
| 162 // arguments (data1 and data2), and should return false in case of error. |
| 163 typedef int (*VP9WorkerHook)(void*, void*); |
| 164 |
| 165 // Platform-dependent implementation details for the worker. |
| 166 typedef struct VP9WorkerImpl VP9WorkerImpl; |
| 167 |
| 168 // Synchronization object used to launch job in the worker thread |
| 169 typedef struct { |
| 170 VP9WorkerImpl *impl_; |
| 171 VP9WorkerStatus status_; |
| 172 VP9WorkerHook hook; // hook to call |
| 173 void *data1; // first argument passed to 'hook' |
| 174 void *data2; // second argument passed to 'hook' |
| 175 int had_error; // return value of the last call to 'hook' |
| 176 } VP9Worker; |
| 177 |
| 178 // The interface for all thread-worker related functions. All these functions |
| 179 // must be implemented. |
| 180 typedef struct { |
| 181 // Must be called first, before any other method. |
| 182 void (*init)(VP9Worker *const worker); |
| 183 // Must be called to initialize the object and spawn the thread. Re-entrant. |
| 184 // Will potentially launch the thread. Returns false in case of error. |
| 185 int (*reset)(VP9Worker *const worker); |
| 186 // Makes sure the previous work is finished. Returns true if worker->had_error |
| 187 // was not set and no error condition was triggered by the working thread. |
| 188 int (*sync)(VP9Worker *const worker); |
| 189 // Triggers the thread to call hook() with data1 and data2 arguments. These |
| 190 // hook/data1/data2 values can be changed at any time before calling this |
| 191 // function, but not be changed afterward until the next call to Sync(). |
| 192 void (*launch)(VP9Worker *const worker); |
| 193 // This function is similar to launch() except that it calls the |
| 194 // hook directly instead of using a thread. Convenient to bypass the thread |
| 195 // mechanism while still using the VP9Worker structs. sync() must |
| 196 // still be called afterward (for error reporting). |
| 197 void (*execute)(VP9Worker *const worker); |
| 198 // Kill the thread and terminate the object. To use the object again, one |
| 199 // must call reset() again. |
| 200 void (*end)(VP9Worker *const worker); |
| 201 } VP9WorkerInterface; |
| 202 |
| 203 // Install a new set of threading functions, overriding the defaults. This |
| 204 // should be done before any workers are started, i.e., before any encoding or |
| 205 // decoding takes place. The contents of the interface struct are copied, it |
| 206 // is safe to free the corresponding memory after this call. This function is |
| 207 // not thread-safe. Return false in case of invalid pointer or methods. |
| 208 int vp9_set_worker_interface(const VP9WorkerInterface *const winterface); |
| 209 |
| 210 // Retrieve the currently set thread worker interface. |
| 211 const VP9WorkerInterface *vp9_get_worker_interface(void); |
| 212 |
| 213 //------------------------------------------------------------------------------ |
| 214 |
| 215 #ifdef __cplusplus |
| 216 } // extern "C" |
| 217 #endif |
| 218 |
| 219 #endif // VP9_DECODER_VP9_THREAD_H_ |
OLD | NEW |