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., 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
  36 AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
  37 {
  38     ALCcontext *Context;
  39     ALsizei i;
  40
  41     Context = GetContextRef();
  42     if(!Context) return;
  43
  44     if(n < 0 || IsBadWritePtr((void*)filters, n * sizeof(ALuint)))
  45         alSetError(Context, AL_INVALID_VALUE);
  46     else
  47     {
  48         ALCdevice *device = Context->Device;
  49         ALenum err;
  50
  51         for(i = 0;i < n;i++)
  52         {
  53             ALfilter *filter = calloc(1, sizeof(ALfilter));
  54             if(!filter)
  55             {
  56                 alSetError(Context, AL_OUT_OF_MEMORY);
  57                 alDeleteFilters(i, filters);
  58                 break;
  59             }
  60             InitFilterParams(filter, AL_FILTER_NULL);
  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         }
  78     }
  79
  80     ALCcontext_DecRef(Context);
  81 }
  82
  83 AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, const ALuint *filters)
  84 {
  85     ALCcontext *Context;
  86     ALCdevice *device;
  87     ALfilter *ALFilter;
  88     ALsizei i;
  89
  90     Context = GetContextRef();
  91     if(!Context) return;
  92
  93     device = Context->Device;
  94     if(n < 0)
  95         alSetError(Context, AL_INVALID_VALUE);
  96     else
  97     {
  98         // Check that all filters are valid
  99         for(i = 0;i < n;i++)
 100         {
 101             if(!filters[i])
 102                 continue;
 103
 104             if(LookupFilter(device, filters[i]) == NULL)
 105             {
 106                 alSetError(Context, AL_INVALID_NAME);
 107                 n = 0;
 108                 break;
 109             }
 110         }
 111
 112         for(i = 0;i < n;i++)
 113         {
 114             // Recheck that the filter is valid, because there could be duplicated names
 115             if((ALFilter=RemoveFilter(device, filters[i])) == NULL)
 116                 continue;
 117             FreeThunkEntry(ALFilter->filter);
 118
 119             memset(ALFilter, 0, sizeof(ALfilter));
 120             free(ALFilter);
 121         }
 122     }
 123
 124     ALCcontext_DecRef(Context);
 125 }
 126
 127 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 128 {
 129     ALCcontext *Context;
 130     ALboolean  result;
 131
 132     Context = GetContextRef();
 133     if(!Context) return AL_FALSE;
 134
 135     result = ((!filter || LookupFilter(Context->Device, filter)) ?
 136               AL_TRUE : AL_FALSE);
 137
 138     ALCcontext_DecRef(Context);
 139
 140     return result;
 141 }
 142
 143 AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
 144 {
 145     ALCcontext *Context;
 146     ALCdevice  *Device;
 147     ALfilter   *ALFilter;
 148
 149     Context = GetContextRef();
 150     if(!Context) return;
 151
 152     Device = Context->Device;
 153     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 154     {
 155         switch(param)
 156         {
 157         case AL_FILTER_TYPE:
 158             if(iValue == AL_FILTER_NULL || iValue == AL_FILTER_LOWPASS)
 159                 InitFilterParams(ALFilter, iValue);
 160             else
 161                 alSetError(Context, AL_INVALID_VALUE);
 162             break;
 163
 164         default:
 165             /* Call the appropriate handler */
 166             ALfilter_SetParami(ALFilter, Context, param, iValue);
 167             break;
 168         }
 169     }
 170     else
 171         alSetError(Context, AL_INVALID_NAME);
 172
 173     ALCcontext_DecRef(Context);
 174 }
 175
 176 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, const ALint *piValues)
 177 {
 178     ALCcontext *Context;
 179     ALCdevice  *Device;
 180     ALfilter   *ALFilter;
 181
 182     switch(param)
 183     {
 184         case AL_FILTER_TYPE:
 185             alFilteri(filter, param, piValues[0]);
 186             return;
 187     }
 188
 189     Context = GetContextRef();
 190     if(!Context) return;
 191
 192     Device = Context->Device;
 193     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 194     {
 195         /* Call the appropriate handler */
 196         ALfilter_SetParamiv(ALFilter, Context, param, piValues);
 197     }
 198     else
 199         alSetError(Context, AL_INVALID_NAME);
 200
 201     ALCcontext_DecRef(Context);
 202 }
 203
 204 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
 205 {
 206     ALCcontext *Context;
 207     ALCdevice  *Device;
 208     ALfilter   *ALFilter;
 209
 210     Context = GetContextRef();
 211     if(!Context) return;
 212
 213     Device = Context->Device;
 214     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 215     {
 216         /* Call the appropriate handler */
 217         ALfilter_SetParamf(ALFilter, Context, param, flValue);
 218     }
 219     else
 220         alSetError(Context, AL_INVALID_NAME);
 221
 222     ALCcontext_DecRef(Context);
 223 }
 224
 225 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, const ALfloat *pflValues)
 226 {
 227     ALCcontext *Context;
 228     ALCdevice  *Device;
 229     ALfilter   *ALFilter;
 230
 231     Context = GetContextRef();
 232     if(!Context) return;
 233
 234     Device = Context->Device;
 235     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 236     {
 237         /* Call the appropriate handler */
 238         ALfilter_SetParamfv(ALFilter, Context, param, pflValues);
 239     }
 240     else
 241         alSetError(Context, AL_INVALID_NAME);
 242
 243     ALCcontext_DecRef(Context);
 244 }
 245
 246 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
 247 {
 248     ALCcontext *Context;
 249     ALCdevice  *Device;
 250     ALfilter   *ALFilter;
 251
 252     Context = GetContextRef();
 253     if(!Context) return;
 254
 255     Device = Context->Device;
 256     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 257     {
 258         switch(param)
 259         {
 260         case AL_FILTER_TYPE:
 261             *piValue = ALFilter->type;
 262             break;
 263
 264         default:
 265             /* Call the appropriate handler */
 266             ALfilter_GetParami(ALFilter, Context, param, piValue);
 267             break;
 268         }
 269     }
 270     else
 271         alSetError(Context, AL_INVALID_NAME);
 272
 273     ALCcontext_DecRef(Context);
 274 }
 275
 276 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
 277 {
 278     ALCcontext *Context;
 279     ALCdevice  *Device;
 280     ALfilter   *ALFilter;
 281
 282     switch(param)
 283     {
 284         case AL_FILTER_TYPE:
 285             alGetFilteri(filter, param, piValues);
 286             return;
 287     }
 288
 289     Context = GetContextRef();
 290     if(!Context) return;
 291
 292     Device = Context->Device;
 293     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 294     {
 295         /* Call the appropriate handler */
 296         ALfilter_GetParamiv(ALFilter, Context, param, piValues);
 297     }
 298     else
 299         alSetError(Context, AL_INVALID_NAME);
 300
 301     ALCcontext_DecRef(Context);
 302 }
 303
 304 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
 305 {
 306     ALCcontext *Context;
 307     ALCdevice  *Device;
 308     ALfilter   *ALFilter;
 309
 310     Context = GetContextRef();
 311     if(!Context) return;
 312
 313     Device = Context->Device;
 314     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 315     {
 316         /* Call the appropriate handler */
 317         ALfilter_GetParamf(ALFilter, Context, param, pflValue);
 318     }
 319     else
 320         alSetError(Context, AL_INVALID_NAME);
 321
 322     ALCcontext_DecRef(Context);
 323 }
 324
 325 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 326 {
 327     ALCcontext *Context;
 328     ALCdevice  *Device;
 329     ALfilter   *ALFilter;
 330
 331     Context = GetContextRef();
 332     if(!Context) return;
 333
 334     Device = Context->Device;
 335     if((ALFilter=LookupFilter(Device, filter)) != NULL)
 336     {
 337         /* Call the appropriate handler */
 338         ALfilter_GetParamfv(ALFilter, Context, param, pflValues);
 339     }
 340     else
 341         alSetError(Context, AL_INVALID_NAME);
 342
 343     ALCcontext_DecRef(Context);
 344 }
 345
 346
 347 ALfloat lpCoeffCalc(ALfloat g, ALfloat cw)
 348 {
 349     ALfloat a = 0.0f;
 350
 351     /* Be careful with gains < 0.001, as that causes the coefficient head
 352      * towards 1, which will flatten the signal */
 353     if(g < 0.9999f) /* 1-epsilon */
 354     {
 355         g = maxf(g, 0.001f);
 356         a = (1 - g*cw - aluSqrt(2*g*(1-cw) - g*g*(1 - cw*cw))) /
 357             (1 - g);
 358     }
 359
 360     return a;
 361 }
 362
 363
 364 static void lp_SetParami(ALfilter *filter, ALCcontext *context, ALenum param, ALint val)
 365 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 366 static void lp_SetParamiv(ALfilter *filter, ALCcontext *context, ALenum param, const ALint *vals)
 367 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 368 static void lp_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
 369 {
 370     switch(param)
 371     {
 372         case AL_LOWPASS_GAIN:
 373             if(val >= AL_LOWPASS_MIN_GAIN && val <= AL_LOWPASS_MAX_GAIN)
 374                 filter->Gain = val;
 375             else
 376                 alSetError(context, AL_INVALID_VALUE);
 377             break;
 378
 379         case AL_LOWPASS_GAINHF:
 380             if(val >= AL_LOWPASS_MIN_GAINHF && val <= AL_LOWPASS_MAX_GAINHF)
 381                 filter->GainHF = val;
 382             else
 383                 alSetError(context, AL_INVALID_VALUE);
 384             break;
 385
 386         default:
 387             alSetError(context, AL_INVALID_ENUM);
 388             break;
 389     }
 390 }
 391 static void lp_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
 392 {
 393     lp_SetParamf(filter, context, param, vals[0]);
 394 }
 395
 396 static void lp_GetParami(ALfilter *filter, ALCcontext *context, ALenum param, ALint *val)
 397 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 398 static void lp_GetParamiv(ALfilter *filter, ALCcontext *context, ALenum param, ALint *vals)
 399 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 400 static void lp_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
 401 {
 402     switch(param)
 403     {
 404         case AL_LOWPASS_GAIN:
 405             *val = filter->Gain;
 406             break;
 407
 408         case AL_LOWPASS_GAINHF:
 409             *val = filter->GainHF;
 410             break;
 411
 412         default:
 413             alSetError(context, AL_INVALID_ENUM);
 414             break;
 415     }
 416 }
 417 static void lp_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
 418 {
 419     lp_GetParamf(filter, context, param, vals);
 420 }
 421
 422
 423 static void null_SetParami(ALfilter *filter, ALCcontext *context, ALenum param, ALint val)
 424 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 425 static void null_SetParamiv(ALfilter *filter, ALCcontext *context, ALenum param, const ALint *vals)
 426 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 427 static void null_SetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat val)
 428 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 429 static void null_SetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, const ALfloat *vals)
 430 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 431
 432 static void null_GetParami(ALfilter *filter, ALCcontext *context, ALenum param, ALint *val)
 433 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 434 static void null_GetParamiv(ALfilter *filter, ALCcontext *context, ALenum param, ALint *vals)
 435 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 436 static void null_GetParamf(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *val)
 437 { (void)filter;(void)param;(void)val; alSetError(context, AL_INVALID_ENUM); }
 438 static void null_GetParamfv(ALfilter *filter, ALCcontext *context, ALenum param, ALfloat *vals)
 439 { (void)filter;(void)param;(void)vals; alSetError(context, AL_INVALID_ENUM); }
 440
 441
 442 ALvoid ReleaseALFilters(ALCdevice *device)
 443 {
 444     ALsizei i;
 445     for(i = 0;i < device->FilterMap.size;i++)
 446     {
 447         ALfilter *temp = device->FilterMap.array[i].value;
 448         device->FilterMap.array[i].value = NULL;
 449
 450         // Release filter structure
 451         FreeThunkEntry(temp->filter);
 452         memset(temp, 0, sizeof(ALfilter));
 453         free(temp);
 454     }
 455 }
 456
 457
 458 static void InitFilterParams(ALfilter *filter, ALenum type)
 459 {
 460     if(type == AL_FILTER_LOWPASS)
 461     {
 462         filter->Gain = AL_LOWPASS_DEFAULT_GAIN;
 463         filter->GainHF = AL_LOWPASS_DEFAULT_GAINHF;
 464
 465         filter->SetParami  = lp_SetParami;
 466         filter->SetParamiv = lp_SetParamiv;
 467         filter->SetParamf  = lp_SetParamf;
 468         filter->SetParamfv = lp_SetParamfv;
 469         filter->GetParami  = lp_GetParami;
 470         filter->GetParamiv = lp_GetParamiv;
 471         filter->GetParamf  = lp_GetParamf;
 472         filter->GetParamfv = lp_GetParamfv;
 473     }
 474     else
 475     {
 476         filter->SetParami  = null_SetParami;
 477         filter->SetParamiv = null_SetParamiv;
 478         filter->SetParamf  = null_SetParamf;
 479         filter->SetParamfv = null_SetParamfv;
 480         filter->GetParami  = null_GetParami;
 481         filter->GetParamiv = null_GetParamiv;
 482         filter->GetParamf  = null_GetParamf;
 483         filter->GetParamfv = null_GetParamfv;
 484     }
 485     filter->type = type;
 486 }