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 static ALfilter *g_FilterList;
  33 static ALuint    g_FilterCount;
  34
  35 static void InitFilterParams(ALfilter *filter, ALenum type);
  36
  37
  38 AL_API ALvoid AL_APIENTRY alGenFilters(ALsizei n, ALuint *filters)
  39 {
  40     ALCcontext *Context;
  41     ALsizei i;
  42
  43     Context = alcGetCurrentContext();
  44     SuspendContext(Context);
  45
  46     if (n > 0)
  47     {
  48         // Check that enough memory has been allocted in the 'filters' array for n Filters
  49         if (!IsBadWritePtr((void*)filters, n * sizeof(ALuint)))
  50         {
  51             ALfilter **list = &g_FilterList;
  52             while(*list)
  53                 list = &(*list)->next;
  54
  55             i = 0;
  56             while(i < n)
  57             {
  58                 *list = calloc(1, sizeof(ALfilter));
  59                 if(!(*list))
  60                 {
  61                     // We must have run out or memory
  62                     alDeleteFilters(i, filters);
  63                     alSetError(AL_OUT_OF_MEMORY);
  64                     break;
  65                 }
  66
  67                 filters[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  68                 (*list)->filter = filters[i];
  69
  70                 InitFilterParams(*list, AL_FILTER_NULL);
  71                 g_FilterCount++;
  72                 i++;
  73
  74                 list = &(*list)->next;
  75             }
  76         }
  77     }
  78
  79     ProcessContext(Context);
  80 }
  81
  82 AL_API ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
  83 {
  84     ALCcontext *Context;
  85     ALfilter *ALFilter;
  86     ALsizei i;
  87
  88     Context = alcGetCurrentContext();
  89     SuspendContext(Context);
  90
  91     if (n >= 0)
  92     {
  93         // Check that all filters are valid
  94         for (i = 0; i < n; i++)
  95         {
  96             if (!alIsFilter(filters[i]))
  97             {
  98                 alSetError(AL_INVALID_NAME);
  99                 break;
 100             }
 101         }
 102
 103         if (i == n)
 104         {
 105             // All filters are valid
 106             for (i = 0; i < n; i++)
 107             {
 108                 // Recheck that the filter is valid, because there could be duplicated names
 109                 if (filters[i] && alIsFilter(filters[i]))
 110                 {
 111                     ALfilter **list;
 112
 113                     ALFilter = ((ALfilter*)ALTHUNK_LOOKUPENTRY(filters[i]));
 114
 115                     // Remove Source from list of Sources
 116                     list = &g_FilterList;
 117                     while(*list && *list != ALFilter)
 118                          list = &(*list)->next;
 119
 120                     if(*list)
 121                         *list = (*list)->next;
 122                     ALTHUNK_REMOVEENTRY(ALFilter->filter);
 123
 124                     memset(ALFilter, 0, sizeof(ALfilter));
 125                     free(ALFilter);
 126
 127                     g_FilterCount--;
 128                 }
 129             }
 130         }
 131     }
 132     else
 133         alSetError(AL_INVALID_VALUE);
 134
 135     ProcessContext(Context);
 136 }
 137
 138 AL_API ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 139 {
 140     ALCcontext *Context;
 141     ALfilter **list;
 142
 143     Context = alcGetCurrentContext();
 144     SuspendContext(Context);
 145
 146     list = &g_FilterList;
 147     while(*list && (*list)->filter != filter)
 148         list = &(*list)->next;
 149
 150     ProcessContext(Context);
 151
 152     return ((*list || !filter) ? AL_TRUE : AL_FALSE);
 153 }
 154
 155 AL_API ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
 156 {
 157     ALCcontext *Context;
 158
 159     Context = alcGetCurrentContext();
 160     SuspendContext(Context);
 161
 162     if (filter && alIsFilter(filter))
 163     {
 164         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 165
 166         switch(param)
 167         {
 168         case AL_FILTER_TYPE:
 169             if(iValue == AL_FILTER_NULL ||
 170                iValue == AL_FILTER_LOWPASS)
 171                 InitFilterParams(ALFilter, iValue);
 172             else
 173                 alSetError(AL_INVALID_VALUE);
 174             break;
 175
 176         default:
 177             alSetError(AL_INVALID_ENUM);
 178             break;
 179         }
 180     }
 181     else
 182         alSetError(AL_INVALID_NAME);
 183
 184     ProcessContext(Context);
 185 }
 186
 187 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
 188 {
 189     ALCcontext *Context;
 190
 191     Context = alcGetCurrentContext();
 192     SuspendContext(Context);
 193
 194     if (filter && alIsFilter(filter))
 195     {
 196         switch(param)
 197         {
 198         case AL_FILTER_TYPE:
 199             alFilteri(filter, param, piValues[0]);
 200             break;
 201
 202         default:
 203             alSetError(AL_INVALID_ENUM);
 204             break;
 205         }
 206     }
 207     else
 208         alSetError(AL_INVALID_NAME);
 209
 210     ProcessContext(Context);
 211 }
 212
 213 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
 214 {
 215     ALCcontext *Context;
 216
 217     Context = alcGetCurrentContext();
 218     SuspendContext(Context);
 219
 220     if (filter && alIsFilter(filter))
 221     {
 222         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 223
 224         switch(param)
 225         {
 226         case AL_LOWPASS_GAIN:
 227             if(ALFilter->type == AL_FILTER_LOWPASS)
 228             {
 229                 if(flValue >= 0.0f && flValue <= 1.0f)
 230                     ALFilter->Gain = flValue;
 231             }
 232             else
 233                 alSetError(AL_INVALID_ENUM);
 234             break;
 235
 236         case AL_LOWPASS_GAINHF:
 237             if(ALFilter->type == AL_FILTER_LOWPASS)
 238             {
 239                 if(flValue >= 0.0f && flValue <= 1.0f)
 240                     ALFilter->GainHF = flValue;
 241             }
 242             else
 243                 alSetError(AL_INVALID_ENUM);
 244             break;
 245
 246         default:
 247             alSetError(AL_INVALID_ENUM);
 248             break;
 249         }
 250     }
 251     else
 252         alSetError(AL_INVALID_NAME);
 253
 254     ProcessContext(Context);
 255 }
 256
 257 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 258 {
 259     ALCcontext *Context;
 260
 261     Context = alcGetCurrentContext();
 262     SuspendContext(Context);
 263
 264     if (filter && alIsFilter(filter))
 265     {
 266         switch(param)
 267         {
 268         case AL_LOWPASS_GAIN:
 269         case AL_LOWPASS_GAINHF:
 270             alFilterf(filter, param, pflValues[0]);
 271             break;
 272
 273         default:
 274             alSetError(AL_INVALID_ENUM);
 275             break;
 276         }
 277     }
 278     else
 279         alSetError(AL_INVALID_NAME);
 280
 281     ProcessContext(Context);
 282 }
 283
 284 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
 285 {
 286     ALCcontext *Context;
 287
 288     (void)piValue;
 289
 290     Context = alcGetCurrentContext();
 291     SuspendContext(Context);
 292
 293     if (filter && alIsFilter(filter))
 294     {
 295         switch(param)
 296         {
 297         default:
 298             alSetError(AL_INVALID_ENUM);
 299             break;
 300         }
 301     }
 302     else
 303         alSetError(AL_INVALID_NAME);
 304
 305     ProcessContext(Context);
 306 }
 307
 308 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
 309 {
 310     ALCcontext *Context;
 311
 312     (void)piValues;
 313
 314     Context = alcGetCurrentContext();
 315     SuspendContext(Context);
 316
 317     if (filter && alIsFilter(filter))
 318     {
 319         switch(param)
 320         {
 321         default:
 322             alSetError(AL_INVALID_ENUM);
 323             break;
 324         }
 325     }
 326     else
 327         alSetError(AL_INVALID_NAME);
 328
 329     ProcessContext(Context);
 330 }
 331
 332 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
 333 {
 334     ALCcontext *Context;
 335
 336     Context = alcGetCurrentContext();
 337     SuspendContext(Context);
 338
 339     if (filter && alIsFilter(filter))
 340     {
 341         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 342
 343         switch(param)
 344         {
 345         case AL_LOWPASS_GAIN:
 346             if(ALFilter->type == AL_FILTER_LOWPASS)
 347                 *pflValue = ALFilter->Gain;
 348             else
 349                 alSetError(AL_INVALID_ENUM);
 350             break;
 351
 352         case AL_LOWPASS_GAINHF:
 353             if(ALFilter->type == AL_FILTER_LOWPASS)
 354                 *pflValue = ALFilter->GainHF;
 355             else
 356                 alSetError(AL_INVALID_ENUM);
 357             break;
 358
 359         default:
 360             alSetError(AL_INVALID_ENUM);
 361             break;
 362         }
 363     }
 364     else
 365         alSetError(AL_INVALID_NAME);
 366
 367     ProcessContext(Context);
 368 }
 369
 370 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 371 {
 372     ALCcontext *Context;
 373
 374     Context = alcGetCurrentContext();
 375     SuspendContext(Context);
 376
 377     if (filter && alIsFilter(filter))
 378     {
 379         switch(param)
 380         {
 381         case AL_LOWPASS_GAIN:
 382         case AL_LOWPASS_GAINHF:
 383             alGetFilterf(filter, param, pflValues);
 384             break;
 385
 386         default:
 387             alSetError(AL_INVALID_ENUM);
 388             break;
 389         }
 390     }
 391     else
 392         alSetError(AL_INVALID_NAME);
 393
 394     ProcessContext(Context);
 395 }
 396
 397
 398 ALvoid ReleaseALFilters(ALvoid)
 399 {
 400 #ifdef _DEBUG
 401     if(g_FilterCount > 0)
 402         AL_PRINT("exit() %d Filter(s) NOT deleted\n", g_FilterCount);
 403 #endif
 404
 405     while(g_FilterList)
 406     {
 407         ALfilter *temp = g_FilterList;
 408         g_FilterList = g_FilterList->next;
 409
 410         // Release filter structure
 411         memset(temp, 0, sizeof(ALfilter));
 412         free(temp);
 413     }
 414     g_FilterCount = 0;
 415 }
 416
 417
 418 static void InitFilterParams(ALfilter *filter, ALenum type)
 419 {
 420     filter->type = type;
 421
 422     filter->Gain = 1.0;
 423     filter->GainHF = 1.0;
 424 }