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 |