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