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