?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Enable large file support
[openal-soft.git] / OpenAL32 / alFilter.c
blobacfae8a66df41356890a227ae0cae8c497e34776
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 "alMain.h"
26 #include "alu.h"
27 #include "alFilter.h"
28 #include "alThunk.h"
29 #include "alError.h"
30
31
32 extern inline struct ALfilter *LookupFilter(ALCdevice *device, ALuint id);
33 extern inline struct ALfilter *RemoveFilter(ALCdevice *device, ALuint id);
34 extern inline ALfloat ALfilterState_processSingle(ALfilterState *filter, ALfloat sample);
35
36 static void InitFilterParams(ALfilter *filter, ALenum type);
37
38
39 AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
40 {
41 ALCdevice *device;
42 ALCcontext *context;
43 ALsizei cur = 0;
44 ALenum err;
45
46 context = GetContextRef();
47 if(!context) return;
48
49 if(!(n >= 0))
50 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
51
52 device = context->Device;
53 for(cur = 0;cur < n;cur++)
54 {
55 ALfilter *filter = calloc(1, sizeof(ALfilter));
56 if(!filter)
57 {
58 alDeleteFilters(cur, filters);
59 SET_ERROR_AND_GOTO(context, AL_OUT_OF_MEMORY, done);
60 }
61 InitFilterParams(filter, AL_FILTER_NULL);
62
63 err = NewThunkEntry(&filter->id);
64 if(err == AL_NO_ERROR)
65 err = InsertUIntMapEntry(&device->FilterMap, filter->id, filter);
66 if(err != AL_NO_ERROR)
67 {
68 FreeThunkEntry(filter->id);
69 memset(filter, 0, sizeof(ALfilter));
70 free(filter);
71
72 alDeleteFilters(cur, filters);
73 SET_ERROR_AND_GOTO(context, err, done);
74 }
75
76 filters[cur] = filter->id;
77 }
78
79 done:
80 ALCcontext_DecRef(context);
81 }
82
83 AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
84 {
85 ALCdevice *device;
86 ALCcontext *context;
87 ALfilter *filter;
88 ALsizei i;
89
90 context = GetContextRef();
91 if(!context) return;
92
93 if(!(n >= 0))
94 SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
95
96 device = context->Device;
97 for(i = 0;i < n;i++)
98 {
99 if(filters[i] && LookupFilter(device, filters[i]) == NULL)
100 SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
101 }
102 for(i = 0;i < n;i++)
103 {
104 if((filter=RemoveFilter(device, filters[i])) == NULL)
105 continue;
106 FreeThunkEntry(filter->id);
107
108 memset(filter, 0, sizeof(*filter));
109 free(filter);
110 }
111
112 done:
113 ALCcontext_DecRef(context);
114 }
115
116 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
117 {
118 ALCcontext *Context;
119 ALboolean result;
120
121 Context = GetContextRef();
122 if(!Context) return AL_FALSE;
123
124 result = ((!filter || LookupFilter(Context->Device, filter)) ?
125 AL_TRUE : AL_FALSE);
126
127 ALCcontext_DecRef(Context);
128
129 return result;
130 }
131
132 AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint value)
133 {
134 ALCcontext *Context;
135 ALCdevice *Device;
136 ALfilter *ALFilter;
137
138 Context = GetContextRef();
139 if(!Context) return;
140
141 Device = Context->Device;
142 if((ALFilter=LookupFilter(Device, filter)) == NULL)
143 alSetError(Context, AL_INVALID_NAME);
144 else
145 {
146 if(param == AL_FILTER_TYPE)
147 {
148 if(value == AL_FILTER_NULL || value == AL_FILTER_LOWPASS ||
149 value == AL_FILTER_HIGHPASS || value == AL_FILTER_BANDPASS)
150 InitFilterParams(ALFilter, value);
151 else
152 alSetError(Context, AL_INVALID_VALUE);
153 }
154 else
155 {
156 /* Call the appropriate handler */
157 ALfilter_SetParami(ALFilter, Context, param, value);
158 }
159 }
160
161 ALCcontext_DecRef(Context);
162 }
163
164 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *values)
165 {
166 ALCcontext *Context;
167 ALCdevice *Device;
168 ALfilter *ALFilter;
169
170 switch(param)
171 {
172 case AL_FILTER_TYPE:
173 alFilteri(filter, param, values[0]);
174 return;
175 }
176
177 Context = GetContextRef();
178 if(!Context) return;
179
180 Device = Context->Device;
181 if((ALFilter=LookupFilter(Device, filter)) == NULL)
182 alSetError(Context, AL_INVALID_NAME);
183 else
184 {
185 /* Call the appropriate handler */
186 ALfilter_SetParamiv(ALFilter, Context, param, values);
187 }
188
189 ALCcontext_DecRef(Context);
190 }
191
192 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat value)
193 {
194 ALCcontext *Context;
195 ALCdevice *Device;
196 ALfilter *ALFilter;
197
198 Context = GetContextRef();
199 if(!Context) return;
200
201 Device = Context->Device;
202 if((ALFilter=LookupFilter(Device, filter)) == NULL)
203 alSetError(Context, AL_INVALID_NAME);
204 else
205 {
206 /* Call the appropriate handler */
207 ALfilter_SetParamf(ALFilter, Context, param, value);
208 }
209
210 ALCcontext_DecRef(Context);
211 }
212
213 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *values)
214 {
215 ALCcontext *Context;
216 ALCdevice *Device;
217 ALfilter *ALFilter;
218
219 Context = GetContextRef();
220 if(!Context) return;
221
222 Device = Context->Device;
223 if((ALFilter=LookupFilter(Device, filter)) == NULL)
224 alSetError(Context, AL_INVALID_NAME);
225 else
226 {
227 /* Call the appropriate handler */
228 ALfilter_SetParamfv(ALFilter, Context, param, values);
229 }
230
231 ALCcontext_DecRef(Context);
232 }
233
234 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *value)
235 {
236 ALCcontext *Context;
237 ALCdevice *Device;
238 ALfilter *ALFilter;
239
240 Context = GetContextRef();
241 if(!Context) return;
242
243 Device = Context->Device;
244 if((ALFilter=LookupFilter(Device, filter)) == NULL)
245 alSetError(Context, AL_INVALID_NAME);
246 else
247 {
248 if(param == AL_FILTER_TYPE)
249 *value = ALFilter->type;
250 else
251 {
252 /* Call the appropriate handler */
253 ALfilter_GetParami(ALFilter, Context, param, value);
254 }
255 }
256
257 ALCcontext_DecRef(Context);
258 }
259
260 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *values)
261 {
262 ALCcontext *Context;
263 ALCdevice *Device;
264 ALfilter *ALFilter;
265
266 switch(param)
267 {
268 case AL_FILTER_TYPE:
269 alGetFilteri(filter, param, values);
270 return;
271 }
272
273 Context = GetContextRef();
274 if(!Context) return;
275
276 Device = Context->Device;
277 if((ALFilter=LookupFilter(Device, filter)) == NULL)
278 alSetError(Context, AL_INVALID_NAME);
279 else
280 {
281 /* Call the appropriate handler */
282 ALfilter_GetParamiv(ALFilter, Context, param, values);
283 }
284
285 ALCcontext_DecRef(Context);
286 }
287
288 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *value)
289 {
290 ALCcontext *Context;
291 ALCdevice *Device;
292 ALfilter *ALFilter;
293
294 Context = GetContextRef();
295 if(!Context) return;
296
297 Device = Context->Device;
298 if((ALFilter=LookupFilter(Device, filter)) == NULL)
299 alSetError(Context, AL_INVALID_NAME);
300 else
301 {
302 /* Call the appropriate handler */
303 ALfilter_GetParamf(ALFilter, Context, param, value);
304 }
305
306 ALCcontext_DecRef(Context);
307 }
308
309 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *values)
310 {
311 ALCcontext *Context;
312 ALCdevice *Device;
313 ALfilter *ALFilter;
314
315 Context = GetContextRef();
316 if(!Context) return;
317
318 Device = Context->Device;
319 if((ALFilter=LookupFilter(Device, filter)) == NULL)
320 alSetError(Context, AL_INVALID_NAME);
321 else
322 {
323 /* Call the appropriate handler */
324 ALfilter_GetParamfv(ALFilter, Context, param, values);
325 }
326
327 ALCcontext_DecRef(Context);
328 }
329
330
331 void ALfilterState_clear(ALfilterState *filter)
332 {
333 filter->x[0] = 0.0f;
334 filter->x[1] = 0.0f;
335 filter->y[0] = 0.0f;
336 filter->y[1] = 0.0f;
337 }
338
339 void ALfilterState_setParams(ALfilterState *filter, ALfilterType type, ALfloat gain, ALfloat freq_mult, ALfloat bandwidth)
340 {
341 ALfloat alpha;
342 ALfloat w0;
343
344 // Limit gain to -100dB
345 gain = maxf(gain, 0.00001f);
346
347 w0 = F_2PI * freq_mult;
348
349 /* Calculate filter coefficients depending on filter type */
350 switch(type)
351 {
352 case ALfilterType_HighShelf:
353 alpha = sinf(w0)/2.0f*sqrtf((gain + 1.0f/gain)*(1.0f/0.75f - 1.0f) + 2.0f);
354 filter->b[0] = gain*((gain+1.0f) + (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha);
355 filter->b[1] = -2.0f*gain*((gain-1.0f) + (gain+1.0f)*cosf(w0) );
356 filter->b[2] = gain*((gain+1.0f) + (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha);
357 filter->a[0] = (gain+1.0f) - (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha;
358 filter->a[1] = 2.0f* ((gain-1.0f) - (gain+1.0f)*cosf(w0) );
359 filter->a[2] = (gain+1.0f) - (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha;
360 break;
361 case ALfilterType_LowShelf:
362 alpha = sinf(w0)/2.0f*sqrtf((gain + 1.0f/gain)*(1.0f/0.75f - 1.0f) + 2.0f);
363 filter->b[0] = gain*((gain+1.0f) - (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha);
364 filter->b[1] = 2.0f*gain*((gain-1.0f) - (gain+1.0f)*cosf(w0) );
365 filter->b[2] = gain*((gain+1.0f) - (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha);
366 filter->a[0] = (gain+1.0f) + (gain-1.0f)*cosf(w0) + 2.0f*sqrtf(gain)*alpha;
367 filter->a[1] = -2.0f* ((gain-1.0f) + (gain+1.0f)*cosf(w0) );
368 filter->a[2] = (gain+1.0f) + (gain-1.0f)*cosf(w0) - 2.0f*sqrtf(gain)*alpha;
369 break;
370 case ALfilterType_Peaking:
371 alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
372 filter->b[0] = 1.0f + alpha * gain;
373 filter->b[1] = -2.0f * cosf(w0);
374 filter->b[2] = 1.0f - alpha * gain;
375 filter->a[0] = 1.0f + alpha / gain;
376 filter->a[1] = -2.0f * cosf(w0);
377 filter->a[2] = 1.0f - alpha / gain;
378 break;
379
380 case ALfilterType_LowPass:
381 alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
382 filter->b[0] = (1.0f - cosf(w0)) / 2.0f;
383 filter->b[1] = 1.0f - cosf(w0);
384 filter->b[2] = (1.0f - cosf(w0)) / 2.0f;
385 filter->a[0] = 1.0f + alpha;
386 filter->a[1] = -2.0f * cosf(w0);
387 filter->a[2] = 1.0f - alpha;
388 break;
389 case ALfilterType_HighPass:
390 alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
391 filter->b[0] = (1.0f + cosf(w0)) / 2.0f;
392 filter->b[1] = 1.0f + cosf(w0);
393 filter->b[2] = (1.0f + cosf(w0)) / 2.0f;
394 filter->a[0] = 1.0f + alpha;
395 filter->a[1] = -2.0f * cosf(w0);
396 filter->a[2] = 1.0f - alpha;
397 break;
398 case ALfilterType_BandPass:
399 alpha = sinf(w0) * sinhf(logf(2.0f) / 2.0f * bandwidth * w0 / sinf(w0));
400 filter->b[0] = alpha;
401 filter->b[1] = 0;
402 filter->b[2] = -alpha;
403 filter->a[0] = 1.0f + alpha;
404 filter->a[1] = -2.0f * cosf(w0);
405 filter->a[2] = 1.0f - alpha;
406 break;
407 }
408
409 filter->b[2] /= filter->a[0];
410 filter->b[1] /= filter->a[0];
411 filter->b[0] /= filter->a[0];
412 filter->a[2] /= filter->a[0];
413 filter->a[1] /= filter->a[0];
414 filter->a[0] /= filter->a[0];
415
416 filter->process = ALfilterState_processC;
417 }
418
419
420 static void lp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
421 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
422 static void lp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
423 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
424 static void lp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
425 {
426 switch(param)
427 {
428 case AL_LOWPASS_GAIN:
429 if(!(val >= AL_LOWPASS_MIN_GAIN && val <= AL_LOWPASS_MAX_GAIN))
430 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
431 filter->Gain = val;
432 break;
433
434 case AL_LOWPASS_GAINHF:
435 if(!(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF))
436 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
437 filter->GainHF = val;
438 break;
439
440 default:
441 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
442 }
443 }
444 static void lp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
445 {
446 lp_SetParamf(filter, context, param, vals[0]);
447 }
448
449 static void lp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
450 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
451 static void lp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
452 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
453 static void lp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
454 {
455 switch(param)
456 {
457 case AL_LOWPASS_GAIN:
458 *val = filter->Gain;
459 break;
460
461 case AL_LOWPASS_GAINHF:
462 *val = filter->GainHF;
463 break;
464
465 default:
466 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
467 }
468 }
469 static void lp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
470 {
471 lp_GetParamf(filter, context, param, vals);
472 }
473
474
475 static void hp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
476 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
477 static void hp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
478 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
479 static void hp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
480 {
481 switch(param)
482 {
483 case AL_HIGHPASS_GAIN:
484 if(!(val >= AL_HIGHPASS_MIN_GAIN && val <= AL_HIGHPASS_MAX_GAIN))
485 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
486 filter->Gain = val;
487 break;
488
489 case AL_HIGHPASS_GAINLF:
490 if(!(val >= AL_HIGHPASS_MIN_GAINLF && val <= AL_HIGHPASS_MAX_GAINLF))
491 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
492 filter->GainLF = val;
493 break;
494
495 default:
496 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
497 }
498 }
499 static void hp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
500 {
501 hp_SetParamf(filter, context, param, vals[0]);
502 }
503
504 static void hp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
505 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
506 static void hp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
507 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
508 static void hp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
509 {
510 switch(param)
511 {
512 case AL_HIGHPASS_GAIN:
513 *val = filter->Gain;
514 break;
515
516 case AL_HIGHPASS_GAINLF:
517 *val = filter->GainLF;
518 break;
519
520 default:
521 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
522 }
523 }
524 static void hp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
525 {
526 hp_GetParamf(filter, context, param, vals);
527 }
528
529
530 static void bp_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
531 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
532 static void bp_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
533 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
534 static void bp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
535 {
536 switch(param)
537 {
538 case AL_BANDPASS_GAIN:
539 if(!(val >= AL_BANDPASS_MIN_GAIN && val <= AL_BANDPASS_MAX_GAIN))
540 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
541 filter->Gain = val;
542 break;
543
544 case AL_BANDPASS_GAINHF:
545 if(!(val >= AL_BANDPASS_MIN_GAINHF && val <= AL_BANDPASS_MAX_GAINHF))
546 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
547 filter->GainHF = val;
548 break;
549
550 case AL_BANDPASS_GAINLF:
551 if(!(val >= AL_BANDPASS_MIN_GAINLF && val <= AL_BANDPASS_MAX_GAINLF))
552 SET_ERROR_AND_RETURN(context, AL_INVALID_VALUE);
553 filter->GainLF = val;
554 break;
555
556 default:
557 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
558 }
559 }
560 static void bp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
561 {
562 bp_SetParamf(filter, context, param, vals[0]);
563 }
564
565 static void bp_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
566 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
567 static void bp_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
568 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
569 static void bp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
570 {
571 switch(param)
572 {
573 case AL_BANDPASS_GAIN:
574 *val = filter->Gain;
575 break;
576
577 case AL_BANDPASS_GAINHF:
578 *val = filter->GainHF;
579 break;
580
581 case AL_BANDPASS_GAINLF:
582 *val = filter->GainLF;
583 break;
584
585 default:
586 SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM);
587 }
588 }
589 static void bp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
590 {
591 bp_GetParamf(filter, context, param, vals);
592 }
593
594
595 static void null_SetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint UNUSED(val))
596 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
597 static void null_SetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALint *UNUSED(vals))
598 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
599 static void null_SetParamf(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat UNUSED(val))
600 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
601 static void null_SetParamfv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), const ALfloat *UNUSED(vals))
602 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
603
604 static void null_GetParami(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(val))
605 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
606 static void null_GetParamiv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALint *UNUSED(vals))
607 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
608 static void null_GetParamf(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(val))
609 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
610 static void null_GetParamfv(ALfilter *UNUSED(filter), ALCcontext *context, ALenum UNUSED(param), ALfloat *UNUSED(vals))
611 { SET_ERROR_AND_RETURN(context, AL_INVALID_ENUM); }
612
613
614 ALvoid ReleaseALFilters(ALCdevice *device)
615 {
616 ALsizei i;
617 for(i = 0;i < device->FilterMap.size;i++)
618 {
619 ALfilter *temp = device->FilterMap.array[i].value;
620 device->FilterMap.array[i].value = NULL;
621
622 // Release filter structure
623 FreeThunkEntry(temp->id);
624 memset(temp, 0, sizeof(ALfilter));
625 free(temp);
626 }
627 }
628
629
630 static void InitFilterParams(ALfilter *filter, ALenum type)
631 {
632 if(type == AL_FILTER_LOWPASS)
633 {
634 filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
635 filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
636 filter->HFReference = LOWPASSFREQREF;
637 filter->GainLF = 1.0f;
638 filter->LFReference = HIGHPASSFREQREF;
639
640 filter->SetParami = lp_SetParami;
641 filter->SetParamiv = lp_SetParamiv;
642 filter->SetParamf = lp_SetParamf;
643 filter->SetParamfv = lp_SetParamfv;
644 filter->GetParami = lp_GetParami;
645 filter->GetParamiv = lp_GetParamiv;
646 filter->GetParamf = lp_GetParamf;
647 filter->GetParamfv = lp_GetParamfv;
648 }
649 else if(type == AL_FILTER_HIGHPASS)
650 {
651 filter->Gain = AL_HIGHPASS_DEFAULT_GAIN;
652 filter->GainHF = 1.0f;
653 filter->HFReference = LOWPASSFREQREF;
654 filter->GainLF = AL_HIGHPASS_DEFAULT_GAINLF;
655 filter->LFReference = HIGHPASSFREQREF;
656
657 filter->SetParami = hp_SetParami;
658 filter->SetParamiv = hp_SetParamiv;
659 filter->SetParamf = hp_SetParamf;
660 filter->SetParamfv = hp_SetParamfv;
661 filter->GetParami = hp_GetParami;
662 filter->GetParamiv = hp_GetParamiv;
663 filter->GetParamf = hp_GetParamf;
664 filter->GetParamfv = hp_GetParamfv;
665 }
666 else if(type == AL_FILTER_BANDPASS)
667 {
668 filter->Gain = AL_BANDPASS_DEFAULT_GAIN;
669 filter->GainHF = AL_BANDPASS_DEFAULT_GAINHF;
670 filter->HFReference = LOWPASSFREQREF;
671 filter->GainLF = AL_BANDPASS_DEFAULT_GAINLF;
672 filter->LFReference = HIGHPASSFREQREF;
673
674 filter->SetParami = bp_SetParami;
675 filter->SetParamiv = bp_SetParamiv;
676 filter->SetParamf = bp_SetParamf;
677 filter->SetParamfv = bp_SetParamfv;
678 filter->GetParami = bp_GetParami;
679 filter->GetParamiv = bp_GetParamiv;
680 filter->GetParamf = bp_GetParamf;
681 filter->GetParamfv = bp_GetParamfv;
682 }
683 else
684 {
685 filter->Gain = 1.0f;
686 filter->GainHF = 1.0f;
687 filter->HFReference = LOWPASSFREQREF;
688 filter->GainLF = 1.0f;
689 filter->LFReference = HIGHPASSFREQREF;
690
691 filter->SetParami = null_SetParami;
692 filter->SetParamiv = null_SetParamiv;
693 filter->SetParamf = null_SetParamf;
694 filter->SetParamfv = null_SetParamfv;
695 filter->GetParami = null_GetParami;
696 filter->GetParamiv = null_GetParamiv;
697 filter->GetParamf = null_GetParamf;
698 filter->GetParamfv = null_GetParamfv;
699 }
700 filter->type = type;
701 }
Software OpenAL implementation