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