OpenAL32/alFilter.c

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