12cb7b0dabed3555e4c46e23743d5762aeba4cb7
[ffmpeg.git] / compat / os2threads.h
1 /*
2  * Copyright (c) 2011 KO Myung-Hun <komh@chollian.net>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * os2threads to pthreads wrapper
24  */
25
26 #ifndef COMPAT_OS2THREADS_H
27 #define COMPAT_OS2THREADS_H
28
29 #define INCL_DOS
30 #include <os2.h>
31
32 #undef __STRICT_ANSI__          /* for _beginthread() */
33 #include <stdlib.h>
34
35 #include <sys/builtin.h>
36 #include <sys/fmutex.h>
37
38 #include "libavutil/mem.h"
39
40 typedef TID  pthread_t;
41 typedef void pthread_attr_t;
42
43 typedef HMTX pthread_mutex_t;
44 typedef void pthread_mutexattr_t;
45
46 typedef struct {
47     HEV event_sem;
48     HEV ack_sem;
49     volatile unsigned  wait_count;
50 } pthread_cond_t;
51
52 typedef void pthread_condattr_t;
53
54 typedef struct {
55     volatile int done;
56     _fmutex mtx;
57 } pthread_once_t;
58
59 #define PTHREAD_ONCE_INIT {0, _FMUTEX_INITIALIZER}
60
61 struct thread_arg {
62     void *(*start_routine)(void *);
63     void *arg;
64 };
65
66 static void thread_entry(void *arg)
67 {
68     struct thread_arg *thread_arg = arg;
69
70     thread_arg->start_routine(thread_arg->arg);
71
72     av_free(thread_arg);
73 }
74
75 static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg)
76 {
77     struct thread_arg *thread_arg;
78
79     thread_arg = av_mallocz(sizeof(struct thread_arg));
80     if (!thread_arg)
81         return ENOMEM;
82
83     thread_arg->start_routine = start_routine;
84     thread_arg->arg = arg;
85
86     *thread = _beginthread(thread_entry, NULL, 256 * 1024, thread_arg);
87
88     return 0;
89 }
90
91 static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
92 {
93     DosWaitThread((PTID)&thread, DCWW_WAIT);
94
95     return 0;
96 }
97
98 static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
99 {
100     DosCreateMutexSem(NULL, (PHMTX)mutex, 0, FALSE);
101
102     return 0;
103 }
104
105 static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
106 {
107     DosCloseMutexSem(*(PHMTX)mutex);
108
109     return 0;
110 }
111
112 static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
113 {
114     DosRequestMutexSem(*(PHMTX)mutex, SEM_INDEFINITE_WAIT);
115
116     return 0;
117 }
118
119 static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
120 {
121     DosReleaseMutexSem(*(PHMTX)mutex);
122
123     return 0;
124 }
125
126 static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
127 {
128     DosCreateEventSem(NULL, &cond->event_sem, DCE_POSTONE, FALSE);
129     DosCreateEventSem(NULL, &cond->ack_sem, DCE_POSTONE, FALSE);
130
131     cond->wait_count = 0;
132
133     return 0;
134 }
135
136 static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
137 {
138     DosCloseEventSem(cond->event_sem);
139     DosCloseEventSem(cond->ack_sem);
140
141     return 0;
142 }
143
144 static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
145 {
146     if (!__atomic_cmpxchg32(&cond->wait_count, 0, 0)) {
147         DosPostEventSem(cond->event_sem);
148         DosWaitEventSem(cond->ack_sem, SEM_INDEFINITE_WAIT);
149     }
150
151     return 0;
152 }
153
154 static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
155 {
156     while (!__atomic_cmpxchg32(&cond->wait_count, 0, 0))
157         pthread_cond_signal(cond);
158
159     return 0;
160 }
161
162 static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
163 {
164     __atomic_increment(&cond->wait_count);
165
166     pthread_mutex_unlock(mutex);
167
168     DosWaitEventSem(cond->event_sem, SEM_INDEFINITE_WAIT);
169
170     __atomic_decrement(&cond->wait_count);
171
172     DosPostEventSem(cond->ack_sem);
173
174     pthread_mutex_lock(mutex);
175
176     return 0;
177 }
178
179 static av_always_inline int pthread_once(pthread_once_t *once_control, void (*init_routine)(void))
180 {
181     if (!once_control->done)
182     {
183         _fmutex_request(&once_control->mtx, 0);
184
185         if (!once_control->done)
186         {
187             init_routine();
188
189             once_control->done = 1;
190         }
191
192         _fmutex_release(&once_control->mtx);
193     }
194
195     return 0;
196 }
197 #endif /* COMPAT_OS2THREADS_H */