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