Mercurial > audio-send

comparison OpenAL32/alFilter.c @ 0:f9476ff7637e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial forking of open-al to create multiple listeners
author Robert McIntyre <rlm@mit.edu>
date Tue, 25 Oct 2011 13:02:31 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f9476ff7637e
1 /**
2 * OpenAL cross platform audio library
3 * Copyright (C) 1999-2007 by authors.
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library 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 GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
18 * Or go to http://www.gnu.org/copyleft/lgpl.html
19 */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24
25 #include "AL/al.h"
26 #include "AL/alc.h"
27 #include "alMain.h"
28 #include "alFilter.h"
29 #include "alThunk.h"
30 #include "alError.h"
31
32
33 static void InitFilterParams(ALfilter *filter, ALenum type);
34
35 #define LookupFilter(m, k) ((ALfilter*)LookupUIntMapKey(&(m), (k)))
36
37 AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
38 {
39 ALCcontext *Context;
40 ALsizei i=0;
41
42 Context = GetLockedContext();
43 if(!Context) return;
44
45 if(n < 0 || IsBadWritePtr((void*)filters, n * sizeof(ALuint)))
46 alSetError(Context, AL_INVALID_VALUE);
47 else
48 {
49 ALCdevice *device = Context->Device;
50 ALenum err;
51
52 while(i < n)
53 {
54 ALfilter *filter = calloc(1, sizeof(ALfilter));
55 if(!filter)
56 {
57 alSetError(Context, AL_OUT_OF_MEMORY);
58 alDeleteFilters(i, filters);
59 break;
60 }
61
62 err = NewThunkEntry(&filter->filter);
63 if(err == AL_NO_ERROR)
64 err = InsertUIntMapEntry(&device->FilterMap, filter->filter, filter);
65 if(err != AL_NO_ERROR)
66 {
67 FreeThunkEntry(filter->filter);
68 memset(filter, 0, sizeof(ALfilter));
69 free(filter);
70
71 alSetError(Context, err);
72 alDeleteFilters(i, filters);
73 break;
74 }
75
76 filters[i++] = filter->filter;
77 InitFilterParams(filter, AL_FILTER_NULL);
78 }
79 }
80
81 UnlockContext(Context);
82 }
83
84 AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
85 {
86 ALCcontext *Context;
87 ALCdevice *device;
88 ALfilter *ALFilter;
89 ALboolean Failed;
90 ALsizei i;
91
92 Context = GetLockedContext();
93 if(!Context) return;
94
95 Failed = AL_TRUE;
96 device = Context->Device;
97 if(n < 0)
98 alSetError(Context, AL_INVALID_VALUE);
99 else
100 {
101 Failed = AL_FALSE;
102 // Check that all filters are valid
103 for(i = 0;i < n;i++)
104 {
105 if(!filters[i])
106 continue;
107
108 if(LookupFilter(device->FilterMap, filters[i]) == NULL)
109 {
110 alSetError(Context, AL_INVALID_NAME);
111 Failed = AL_TRUE;
112 break;
113 }
114 }
115 }
116
117 if(!Failed)
118 {
119 // All filters are valid
120 for(i = 0;i < n;i++)
121 {
122 // Recheck that the filter is valid, because there could be duplicated names
123 if((ALFilter=LookupFilter(device->FilterMap, filters[i])) == NULL)
124 continue;
125
126 RemoveUIntMapKey(&device->FilterMap, ALFilter->filter);
127 FreeThunkEntry(ALFilter->filter);
128
129 memset(ALFilter, 0, sizeof(ALfilter));
130 free(ALFilter);
131 }
132 }
133
134 UnlockContext(Context);
135 }
136
137 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
138 {
139 ALCcontext *Context;
140 ALboolean result;
141
142 Context = GetLockedContext();
143 if(!Context) return AL_FALSE;
144
145 result = ((!filter || LookupFilter(Context->Device->FilterMap, filter)) ?
146 AL_TRUE : AL_FALSE);
147
148 UnlockContext(Context);
149
150 return result;
151 }
152
153 AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
154 {
155 ALCcontext *Context;
156 ALCdevice *Device;
157 ALfilter *ALFilter;
158
159 Context = GetLockedContext();
160 if(!Context) return;
161
162 Device = Context->Device;
163 if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
164 {
165 switch(param)
166 {
167 case AL_FILTER_TYPE:
168 if(iValue == AL_FILTER_NULL ||
169 iValue == AL_FILTER_LOWPASS)
170 InitFilterParams(ALFilter, iValue);
171 else
172 alSetError(Context, AL_INVALID_VALUE);
173 break;
174
175 default:
176 alSetError(Context, AL_INVALID_ENUM);
177 break;
178 }
179 }
180 else
181 alSetError(Context, AL_INVALID_NAME);
182
183 UnlockContext(Context);
184 }
185
186 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
187 {
188 ALCcontext *Context;
189 ALCdevice *Device;
190
191 switch(param)
192 {
193 case AL_FILTER_TYPE:
194 alFilteri(filter, param, piValues[0]);
195 return;
196 }
197
198 Context = GetLockedContext();
199 if(!Context) return;
200
201 Device = Context->Device;
202 if(LookupFilter(Device->FilterMap, filter) != NULL)
203 {
204 switch(param)
205 {
206 default:
207 alSetError(Context, AL_INVALID_ENUM);
208 break;
209 }
210 }
211 else
212 alSetError(Context, AL_INVALID_NAME);
213
214 UnlockContext(Context);
215 }
216
217 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
218 {
219 ALCcontext *Context;
220 ALCdevice *Device;
221 ALfilter *ALFilter;
222
223 Context = GetLockedContext();
224 if(!Context) return;
225
226 Device = Context->Device;
227 if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
228 {
229 switch(ALFilter->type)
230 {
231 case AL_FILTER_LOWPASS:
232 switch(param)
233 {
234 case AL_LOWPASS_GAIN:
235 if(flValue >= AL_LOWPASS_MIN_GAIN &&
236 flValue <= AL_LOWPASS_MAX_GAIN)
237 ALFilter->Gain = flValue;
238 else
239 alSetError(Context, AL_INVALID_VALUE);
240 break;
241
242 case AL_LOWPASS_GAINHF:
243 if(flValue >= AL_LOWPASS_MIN_GAINHF &&
244 flValue <= AL_LOWPASS_MAX_GAINHF)
245 ALFilter->GainHF = flValue;
246 else
247 alSetError(Context, AL_INVALID_VALUE);
248 break;
249
250 default:
251 alSetError(Context, AL_INVALID_ENUM);
252 break;
253 }
254 break;
255
256 default:
257 alSetError(Context, AL_INVALID_ENUM);
258 break;
259 }
260 }
261 else
262 alSetError(Context, AL_INVALID_NAME);
263
264 UnlockContext(Context);
265 }
266
267 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
268 {
269 /* There are currently no multi-value filter parameters */
270 alFilterf(filter, param, pflValues[0]);
271 }
272
273 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
274 {
275 ALCcontext *Context;
276 ALCdevice *Device;
277 ALfilter *ALFilter;
278
279 Context = GetLockedContext();
280 if(!Context) return;
281
282 Device = Context->Device;
283 if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
284 {
285 switch(param)
286 {
287 case AL_FILTER_TYPE:
288 *piValue = ALFilter->type;
289 break;
290
291 default:
292 alSetError(Context, AL_INVALID_ENUM);
293 break;
294 }
295 }
296 else
297 alSetError(Context, AL_INVALID_NAME);
298
299 UnlockContext(Context);
300 }
301
302 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
303 {
304 ALCcontext *Context;
305 ALCdevice *Device;
306
307 switch(param)
308 {
309 case AL_FILTER_TYPE:
310 alGetFilteri(filter, param, piValues);
311 return;
312 }
313
314 Context = GetLockedContext();
315 if(!Context) return;
316
317 Device = Context->Device;
318 if(LookupFilter(Device->FilterMap, filter) != NULL)
319 {
320 switch(param)
321 {
322 default:
323 alSetError(Context, AL_INVALID_ENUM);
324 break;
325 }
326 }
327 else
328 alSetError(Context, AL_INVALID_NAME);
329
330 UnlockContext(Context);
331 }
332
333 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
334 {
335 ALCcontext *Context;
336 ALCdevice *Device;
337 ALfilter *ALFilter;
338
339 Context = GetLockedContext();
340 if(!Context) return;
341
342 Device = Context->Device;
343 if((ALFilter=LookupFilter(Device->FilterMap, filter)) != NULL)
344 {
345 switch(ALFilter->type)
346 {
347 case AL_FILTER_LOWPASS:
348 switch(param)
349 {
350 case AL_LOWPASS_GAIN:
351 *pflValue = ALFilter->Gain;
352 break;
353
354 case AL_LOWPASS_GAINHF:
355 *pflValue = ALFilter->GainHF;
356 break;
357
358 default:
359 alSetError(Context, AL_INVALID_ENUM);
360 break;
361 }
362 break;
363
364 default:
365 alSetError(Context, AL_INVALID_ENUM);
366 break;
367 }
368 }
369 else
370 alSetError(Context, AL_INVALID_NAME);
371
372 UnlockContext(Context);
373 }
374
375 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
376 {
377 /* There are currently no multi-value filter parameters */
378 alGetFilterf(filter, param, pflValues);
379 }
380
381
382 ALfloat lpCoeffCalc(ALfloat g, ALfloat cw)
383 {
384 ALfloat a = 0.0f;
385
386 /* Be careful with gains < 0.01, as that causes the coefficient
387 * head towards 1, which will flatten the signal */
388 if(g < 0.9999f) /* 1-epsilon */
389 {
390 g = maxf(g, 0.01f);
391 a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) /
392 (1 - g);
393 }
394
395 return a;
396 }
397
398 ALvoid ReleaseALFilters(ALCdevice *device)
399 {
400 ALsizei i;
401 for(i = 0;i < device->FilterMap.size;i++)
402 {
403 ALfilter *temp = device->FilterMap.array[i].value;
404 device->FilterMap.array[i].value = NULL;
405
406 // Release filter structure
407 FreeThunkEntry(temp->filter);
408 memset(temp, 0, sizeof(ALfilter));
409 free(temp);
410 }
411 }
412
413
414 static void InitFilterParams(ALfilter *filter, ALenum type)
415 {
416 filter->type = type;
417
418 filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
419 filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
420 }