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