This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_timer.c
311 lines (280 loc) · 8.13 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2010 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include "SDL_timer.h"
#include "SDL_timer_c.h"
#include "SDL_mutex.h"
#include "SDL_systimer.h"
/* #define DEBUG_TIMERS */
int SDL_timer_started = 0;
int SDL_timer_running = 0;
/* Data to handle a single periodic alarm */
Uint32 SDL_alarm_interval = 0;
SDL_TimerCallback SDL_alarm_callback;
/* Data used for a thread-based timer */
static int SDL_timer_threaded = 0;
41
42
43
44
45
46
47
struct _SDL_TimerID
{
Uint32 interval;
SDL_NewTimerCallback cb;
void *param;
Uint32 last_alarm;
struct _SDL_TimerID *next;
48
49
50
51
};
static SDL_TimerID SDL_timers = NULL;
static SDL_mutex *SDL_timer_mutex;
52
static volatile SDL_bool list_changed = SDL_FALSE;
53
54
55
56
/* Set whether or not the timer should use a thread.
This should not be called while the timer subsystem is running.
*/
57
58
int
SDL_SetTimerThreaded(int value)
59
{
60
int retval;
61
62
63
64
65
66
67
68
69
if (SDL_timer_started) {
SDL_SetError("Timer already initialized");
retval = -1;
} else {
retval = 0;
SDL_timer_threaded = value;
}
return retval;
70
71
}
72
73
int
SDL_TimerInit(void)
74
{
75
int retval;
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
retval = 0;
if (SDL_timer_started) {
SDL_TimerQuit();
}
if (!SDL_timer_threaded) {
retval = SDL_SYS_TimerInit();
}
if (SDL_timer_threaded) {
SDL_timer_mutex = SDL_CreateMutex();
}
if (retval == 0) {
SDL_timer_started = 1;
}
return (retval);
91
92
}
93
94
void
SDL_TimerQuit(void)
95
{
96
97
98
99
100
101
102
103
104
105
SDL_SetTimer(0, NULL);
if (SDL_timer_threaded < 2) {
SDL_SYS_TimerQuit();
}
if (SDL_timer_threaded) {
SDL_DestroyMutex(SDL_timer_mutex);
SDL_timer_mutex = NULL;
}
SDL_timer_started = 0;
SDL_timer_threaded = 0;
106
107
}
108
109
void
SDL_ThreadedTimerCheck(void)
110
{
111
112
113
Uint32 now, ms;
SDL_TimerID t, prev, next;
SDL_bool removed;
114
115
SDL_mutexP(SDL_timer_mutex);
116
117
now = SDL_GetTicks();
118
119
120
121
122
123
124
125
126
127
128
do {
list_changed = SDL_FALSE;
for (prev = NULL, t = SDL_timers; t; t = next) {
removed = SDL_FALSE;
ms = t->interval - SDL_TIMESLICE;
next = t->next;
if ((int) (now - t->last_alarm) > (int) ms) {
struct _SDL_TimerID timer;
if ((now - t->last_alarm) < t->interval) {
t->last_alarm += t->interval;
129
} else {
130
131
t->last_alarm = now;
}
132
#ifdef DEBUG_TIMERS
133
134
printf("Executing timer %p (thread = %lu)\n",
t, SDL_ThreadID());
135
#endif
136
137
138
139
140
141
142
143
144
145
146
147
148
149
timer = *t;
SDL_mutexV(SDL_timer_mutex);
ms = timer.cb(timer.interval, timer.param);
SDL_mutexP(SDL_timer_mutex);
if (list_changed) {
next = t->next;
for (prev = SDL_timers; prev; prev = prev->next) {
if (prev->next == t)
break;
}
}
if (ms != t->interval) {
if (ms) {
t->interval = ROUND_RESOLUTION(ms);
150
} else {
151
152
153
154
155
156
157
158
159
160
161
162
/* Remove timer from the list */
#ifdef DEBUG_TIMERS
printf("SDL: Removing timer %p\n", t);
#endif
if (prev) {
prev->next = next;
} else {
SDL_timers = next;
}
SDL_free(t);
--SDL_timer_running;
removed = SDL_TRUE;
163
}
164
165
166
167
}
if (list_changed) {
/* Abort, list of timers modified */
break;
168
169
}
}
170
171
172
173
/* Don't update prev if the timer has disappeared */
if (!removed) {
prev = t;
}
174
}
175
176
} while (list_changed);
177
SDL_mutexV(SDL_timer_mutex);
178
179
}
180
181
182
static SDL_TimerID
SDL_AddTimerInternal(Uint32 interval, SDL_NewTimerCallback callback,
void *param)
183
{
184
185
186
187
188
189
190
191
192
193
194
195
SDL_TimerID t;
t = (SDL_TimerID) SDL_malloc(sizeof(struct _SDL_TimerID));
if (t) {
t->interval = ROUND_RESOLUTION(interval);
t->cb = callback;
t->param = param;
t->last_alarm = SDL_GetTicks();
t->next = SDL_timers;
SDL_timers = t;
++SDL_timer_running;
list_changed = SDL_TRUE;
}
196
#ifdef DEBUG_TIMERS
197
198
printf("SDL_AddTimer(%d) = %08x num_timers = %d\n", interval, (Uint32) t,
SDL_timer_running);
199
#endif
200
return t;
201
202
}
203
204
SDL_TimerID
SDL_AddTimer(Uint32 interval, SDL_NewTimerCallback callback, void *param)
205
{
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
SDL_TimerID t;
if (!SDL_timer_mutex) {
if (SDL_timer_started) {
SDL_SetError("This platform doesn't support multiple timers");
} else {
SDL_SetError("You must call SDL_Init(SDL_INIT_TIMER) first");
}
return NULL;
}
if (!SDL_timer_threaded) {
SDL_SetError("Multiple timers require threaded events!");
return NULL;
}
SDL_mutexP(SDL_timer_mutex);
t = SDL_AddTimerInternal(interval, callback, param);
SDL_mutexV(SDL_timer_mutex);
return t;
223
224
}
225
226
SDL_bool
SDL_RemoveTimer(SDL_TimerID id)
227
{
228
229
SDL_TimerID t, prev = NULL;
SDL_bool removed;
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
removed = SDL_FALSE;
SDL_mutexP(SDL_timer_mutex);
/* Look for id in the linked list of timers */
for (t = SDL_timers; t; prev = t, t = t->next) {
if (t == id) {
if (prev) {
prev->next = t->next;
} else {
SDL_timers = t->next;
}
SDL_free(t);
--SDL_timer_running;
removed = SDL_TRUE;
list_changed = SDL_TRUE;
break;
}
}
248
#ifdef DEBUG_TIMERS
249
printf("SDL_RemoveTimer(%08x) = %d num_timers = %d thread = %lu\n",
250
(Uint32) id, removed, SDL_timer_running, SDL_ThreadID());
251
#endif
252
253
SDL_mutexV(SDL_timer_mutex);
return removed;
254
255
256
}
/* Old style callback functions are wrapped through this */
257
258
static Uint32 SDLCALL
callback_wrapper(Uint32 ms, void *param)
259
{
260
261
SDL_TimerCallback func = (SDL_TimerCallback) param;
return (*func) (ms);
262
263
}
264
265
int
SDL_SetTimer(Uint32 ms, SDL_TimerCallback callback)
266
{
267
int retval;
268
269
#ifdef DEBUG_TIMERS
270
printf("SDL_SetTimer(%d)\n", ms);
271
#endif
272
retval = 0;
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
if (SDL_timer_threaded) {
SDL_mutexP(SDL_timer_mutex);
}
if (SDL_timer_running) { /* Stop any currently running timer */
if (SDL_timer_threaded) {
while (SDL_timers) {
SDL_TimerID freeme = SDL_timers;
SDL_timers = SDL_timers->next;
SDL_free(freeme);
}
SDL_timer_running = 0;
list_changed = SDL_TRUE;
} else {
SDL_SYS_StopTimer();
SDL_timer_running = 0;
}
}
if (ms) {
if (SDL_timer_threaded) {
if (SDL_AddTimerInternal
(ms, callback_wrapper, (void *) callback) == NULL) {
retval = -1;
}
} else {
SDL_timer_running = 1;
SDL_alarm_interval = ms;
SDL_alarm_callback = callback;
retval = SDL_SYS_StartTimer();
}
}
if (SDL_timer_threaded) {
SDL_mutexV(SDL_timer_mutex);
}
307
308
return retval;
309
}
310
311
/* vi: set ts=4 sw=4 expandtab: */