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 = GetContextSuspended();
  42
  43     if (n > 0)
  44     {
  45         ALCdevice *device = Context->Device;
  46
  47         // Check that enough memory has been allocted in the 'filters' array for n Filters
  48         if (!IsBadWritePtr((void*)filters, n * sizeof(ALuint)))
  49         {
  50             ALfilter **list = &device->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                 device->FilterCount++;
  71                 i++;
  72
  73                 list = &(*list)->next;
  74             }
  75         }
  76     }
  77
  78     ProcessContext(Context);
  79 }
  80
  81 ALvoid AL_APIENTRY alDeleteFilters(ALsizei n, ALuint *filters)
  82 {
  83     ALCcontext *Context;
  84     ALfilter *ALFilter;
  85     ALsizei i;
  86
  87     Context = GetContextSuspended();
  88
  89     if (n >= 0)
  90     {
  91         ALCdevice *device = Context->Device;
  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 = &device->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                     device->FilterCount--;
 128                 }
 129             }
 130         }
 131     }
 132     else
 133         alSetError(AL_INVALID_VALUE);
 134
 135     ProcessContext(Context);
 136 }
 137
 138 ALboolean AL_APIENTRY alIsFilter(ALuint filter)
 139 {
 140     ALCcontext *Context;
 141     ALfilter *list;
 142
 143     Context = GetContextSuspended();
 144
 145     list = Context->Device->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 ALvoid AL_APIENTRY alFilteri(ALuint filter, ALenum param, ALint iValue)
 155 {
 156     ALCcontext *Context;
 157
 158     Context = GetContextSuspended();
 159
 160     if (filter && alIsFilter(filter))
 161     {
 162         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 163
 164         switch(param)
 165         {
 166         case AL_FILTER_TYPE:
 167             if(iValue == AL_FILTER_NULL ||
 168                iValue == AL_FILTER_LOWPASS)
 169                 InitFilterParams(ALFilter, iValue);
 170             else
 171                 alSetError(AL_INVALID_VALUE);
 172             break;
 173
 174         default:
 175             alSetError(AL_INVALID_ENUM);
 176             break;
 177         }
 178     }
 179     else
 180         alSetError(AL_INVALID_NAME);
 181
 182     ProcessContext(Context);
 183 }
 184
 185 ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
 186 {
 187     ALCcontext *Context;
 188
 189     Context = GetContextSuspended();
 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 ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
 211 {
 212     ALCcontext *Context;
 213
 214     Context = GetContextSuspended();
 215
 216     if (filter && alIsFilter(filter))
 217     {
 218         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 219
 220         switch(ALFilter->type)
 221         {
 222         case AL_FILTER_LOWPASS:
 223             switch(param)
 224             {
 225             case AL_LOWPASS_GAIN:
 226                 if(flValue >= 0.0f && flValue <= 1.0f)
 227                     ALFilter->Gain = flValue;
 228                 else
 229                     alSetError(AL_INVALID_VALUE);
 230                 break;
 231
 232             case AL_LOWPASS_GAINHF:
 233                 if(flValue >= 0.0f && flValue <= 1.0f)
 234                     ALFilter->GainHF = flValue;
 235                 else
 236                     alSetError(AL_INVALID_VALUE);
 237                 break;
 238
 239             default:
 240                 alSetError(AL_INVALID_ENUM);
 241                 break;
 242             }
 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 ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 257 {
 258     ALCcontext *Context;
 259
 260     Context = GetContextSuspended();
 261
 262     if (filter && alIsFilter(filter))
 263     {
 264         switch(param)
 265         {
 266         default:
 267             alFilterf(filter, param, pflValues[0]);
 268             break;
 269         }
 270     }
 271     else
 272         alSetError(AL_INVALID_NAME);
 273
 274     ProcessContext(Context);
 275 }
 276
 277 ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
 278 {
 279     ALCcontext *Context;
 280
 281     Context = GetContextSuspended();
 282
 283     if (filter && alIsFilter(filter))
 284     {
 285         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 286
 287         switch(param)
 288         {
 289         case AL_FILTER_TYPE:
 290             *piValue = ALFilter->type;
 291             break;
 292
 293         default:
 294             alSetError(AL_INVALID_ENUM);
 295             break;
 296         }
 297     }
 298     else
 299         alSetError(AL_INVALID_NAME);
 300
 301     ProcessContext(Context);
 302 }
 303
 304 ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
 305 {
 306     ALCcontext *Context;
 307
 308     Context = GetContextSuspended();
 309
 310     if (filter && alIsFilter(filter))
 311     {
 312         switch(param)
 313         {
 314         case AL_FILTER_TYPE:
 315             alGetFilteri(filter, param, piValues);
 316             break;
 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 ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
 330 {
 331     ALCcontext *Context;
 332
 333     Context = GetContextSuspended();
 334
 335     if (filter && alIsFilter(filter))
 336     {
 337         ALfilter *ALFilter = (ALfilter*)ALTHUNK_LOOKUPENTRY(filter);
 338
 339         switch(ALFilter->type)
 340         {
 341         case AL_FILTER_LOWPASS:
 342             switch(param)
 343             {
 344             case AL_LOWPASS_GAIN:
 345                 *pflValue = ALFilter->Gain;
 346                 break;
 347
 348             case AL_LOWPASS_GAINHF:
 349                 *pflValue = ALFilter->GainHF;
 350                 break;
 351
 352             default:
 353                 alSetError(AL_INVALID_ENUM);
 354                 break;
 355             }
 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 ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 370 {
 371     ALCcontext *Context;
 372
 373     Context = GetContextSuspended();
 374
 375     if (filter && alIsFilter(filter))
 376     {
 377         switch(param)
 378         {
 379         default:
 380             alGetFilterf(filter, param, pflValues);
 381             break;
 382         }
 383     }
 384     else
 385         alSetError(AL_INVALID_NAME);
 386
 387     ProcessContext(Context);
 388 }
 389
 390
 391 ALvoid ReleaseALFilters(ALCdevice *device)
 392 {
 393     ALfilter *list = device->FilterList;
 394     while(list)
 395     {
 396         ALfilter *temp = list;
 397         list = list->next;
 398
 399         // Release filter structure
 400         memset(temp, 0, sizeof(ALfilter));
 401         free(temp);
 402     }
 403     device->FilterList = NULL;
 404     device->FilterCount = 0;
 405 }
 406
 407
 408 static void InitFilterParams(ALfilter *filter, ALenum type)
 409 {
 410     filter->type = type;
 411
 412     filter->Gain = 1.0;
 413     filter->GainHF = 1.0;
 414 }