1 /*
2 * Copyright 2006 Serge van den Boom <svdb@stack.nl>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17 */
18
19 #include "alarm.h"
20
21 #include SDL_INCLUDE(SDL.h)
22 #include "libs/heap.h"
23
24 #include <assert.h>
25 #include <stdlib.h>
26
27
28 Heap *alarmHeap;
29
30
31 static inline Alarm *
Alarm_alloc(void)32 Alarm_alloc(void) {
33 return malloc(sizeof (Alarm));
34 }
35
36 static inline void
Alarm_free(Alarm * alarm)37 Alarm_free(Alarm *alarm) {
38 free(alarm);
39 }
40
41 static inline int
AlarmTime_compare(const AlarmTime t1,const AlarmTime t2)42 AlarmTime_compare(const AlarmTime t1, const AlarmTime t2) {
43 if (t1 < t2)
44 return -1;
45 if (t1 > t2)
46 return 1;
47 return 0;
48 }
49
50 static int
Alarm_compare(const Alarm * a1,const Alarm * a2)51 Alarm_compare(const Alarm *a1, const Alarm *a2) {
52 return AlarmTime_compare(a1->time, a2->time);
53 }
54
55 void
Alarm_init(void)56 Alarm_init(void) {
57 assert(alarmHeap == NULL);
58 alarmHeap = Heap_new((HeapValue_Comparator) Alarm_compare,
59 4, 4, 0.8);
60 }
61
62 void
Alarm_uninit(void)63 Alarm_uninit(void) {
64 assert(alarmHeap != NULL);
65
66 while (Heap_hasMore(alarmHeap)) {
67 Alarm *alarm = (Alarm *) Heap_pop(alarmHeap);
68 Alarm_free(alarm);
69 }
70 Heap_delete(alarmHeap);
71 alarmHeap = NULL;
72 }
73
74 static inline AlarmTime
AlarmTime_nowMs(void)75 AlarmTime_nowMs(void) {
76 return SDL_GetTicks();
77 }
78
79 Alarm *
Alarm_addAbsoluteMs(uint32 ms,AlarmCallback callback,AlarmCallbackArg arg)80 Alarm_addAbsoluteMs(uint32 ms, AlarmCallback callback,
81 AlarmCallbackArg arg) {
82 Alarm *alarm;
83
84 assert(alarmHeap != NULL);
85
86 alarm = Alarm_alloc();
87 alarm->time = ms;
88 alarm->callback = callback;
89 alarm->arg = arg;
90
91 Heap_add(alarmHeap, (HeapValue *) alarm);
92
93 return alarm;
94 }
95
96 Alarm *
Alarm_addRelativeMs(uint32 ms,AlarmCallback callback,AlarmCallbackArg arg)97 Alarm_addRelativeMs(uint32 ms, AlarmCallback callback,
98 AlarmCallbackArg arg) {
99 Alarm *alarm;
100
101 assert(alarmHeap != NULL);
102
103 alarm = Alarm_alloc();
104 alarm->time = AlarmTime_nowMs() + ms;
105 alarm->callback = callback;
106 alarm->arg = arg;
107
108 Heap_add(alarmHeap, (HeapValue *) alarm);
109
110 return alarm;
111 }
112
113 void
Alarm_remove(Alarm * alarm)114 Alarm_remove(Alarm *alarm) {
115 assert(alarmHeap != NULL);
116 Heap_remove(alarmHeap, (HeapValue *) alarm);
117 Alarm_free(alarm);
118 }
119
120 // Process at most one alarm, if its time has come.
121 // It is safe to call this function again from inside a callback function
122 // that it called. It should not be called from multiple threads at once.
123 bool
Alarm_processOne(void)124 Alarm_processOne(void)
125 {
126 AlarmTime now;
127 Alarm *alarm;
128
129 assert(alarmHeap != NULL);
130 if (!Heap_hasMore(alarmHeap))
131 return false;
132
133 now = AlarmTime_nowMs();
134 alarm = (Alarm *) Heap_first(alarmHeap);
135 if (now < alarm->time)
136 return false;
137
138 Heap_pop(alarmHeap);
139 alarm->callback(alarm->arg);
140 Alarm_free(alarm);
141 return true;
142 }
143
144 #if 0
145 // It is safe to call this function again from inside a callback function
146 // that it called. It should not be called from multiple threads at once.
147 void
148 Alarm_processAll(void) {
149 AlarmTime now;
150
151 assert(alarmHeap != NULL);
152
153 now = AlarmTime_nowMs();
154 while (Heap_hasMore(alarmHeap)) {
155 Alarm *alarm = (Alarm *) Heap_first(alarmHeap);
156
157 if (now < alarm->time)
158 break;
159
160 Heap_pop(alarmHeap);
161 alarm->callback(alarm->arg);
162 Alarm_free(alarm);
163 }
164 }
165 #endif
166
167 uint32
Alarm_timeBeforeNextMs(void)168 Alarm_timeBeforeNextMs(void) {
169 Alarm *alarm;
170
171 if (!Heap_hasMore(alarmHeap))
172 return UINT32_MAX;
173
174 alarm = (Alarm *) Heap_first(alarmHeap);
175 return alarmTimeToMsUint32(alarm->time);
176 }
177
178