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 (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 ? 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     (void)iValue;
 157
 158     Context = alcGetCurrentContext();
 159     SuspendContext(Context);
 160
 161     if (alIsFilter(filter))
 162     {
 163         switch(param)
 164         {
 165         default:
 166             alSetError(AL_INVALID_ENUM);
 167             break;
 168         }
 169     }
 170     else
 171         alSetError(AL_INVALID_NAME);
 172
 173     ProcessContext(Context);
 174 }
 175
 176 AL_API ALvoid AL_APIENTRY alFilteriv(ALuint filter, ALenum param, ALint *piValues)
 177 {
 178     ALCcontext *Context;
 179
 180     (void)piValues;
 181
 182     Context = alcGetCurrentContext();
 183     SuspendContext(Context);
 184
 185     if (alIsFilter(filter))
 186     {
 187         switch(param)
 188         {
 189         default:
 190             alSetError(AL_INVALID_ENUM);
 191             break;
 192         }
 193     }
 194     else
 195         alSetError(AL_INVALID_NAME);
 196
 197     ProcessContext(Context);
 198 }
 199
 200 AL_API ALvoid AL_APIENTRY alFilterf(ALuint filter, ALenum param, ALfloat flValue)
 201 {
 202     ALCcontext *Context;
 203
 204     (void)flValue;
 205
 206     Context = alcGetCurrentContext();
 207     SuspendContext(Context);
 208
 209     if (alIsFilter(filter))
 210     {
 211         switch(param)
 212         {
 213         default:
 214             alSetError(AL_INVALID_ENUM);
 215             break;
 216         }
 217     }
 218     else
 219         alSetError(AL_INVALID_NAME);
 220
 221     ProcessContext(Context);
 222 }
 223
 224 AL_API ALvoid AL_APIENTRY alFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 225 {
 226     ALCcontext *Context;
 227
 228     (void)pflValues;
 229
 230     Context = alcGetCurrentContext();
 231     SuspendContext(Context);
 232
 233     if (alIsFilter(filter))
 234     {
 235         switch(param)
 236         {
 237         default:
 238             alSetError(AL_INVALID_ENUM);
 239             break;
 240         }
 241     }
 242     else
 243         alSetError(AL_INVALID_NAME);
 244
 245     ProcessContext(Context);
 246 }
 247
 248 AL_API ALvoid AL_APIENTRY alGetFilteri(ALuint filter, ALenum param, ALint *piValue)
 249 {
 250     ALCcontext *Context;
 251
 252     (void)piValue;
 253
 254     Context = alcGetCurrentContext();
 255     SuspendContext(Context);
 256
 257     if (alIsFilter(filter))
 258     {
 259         switch(param)
 260         {
 261         default:
 262             alSetError(AL_INVALID_ENUM);
 263             break;
 264         }
 265     }
 266     else
 267         alSetError(AL_INVALID_NAME);
 268
 269     ProcessContext(Context);
 270 }
 271
 272 AL_API ALvoid AL_APIENTRY alGetFilteriv(ALuint filter, ALenum param, ALint *piValues)
 273 {
 274     ALCcontext *Context;
 275
 276     (void)piValues;
 277
 278     Context = alcGetCurrentContext();
 279     SuspendContext(Context);
 280
 281     if (alIsFilter(filter))
 282     {
 283         switch(param)
 284         {
 285         default:
 286             alSetError(AL_INVALID_ENUM);
 287             break;
 288         }
 289     }
 290     else
 291         alSetError(AL_INVALID_NAME);
 292
 293     ProcessContext(Context);
 294 }
 295
 296 AL_API ALvoid AL_APIENTRY alGetFilterf(ALuint filter, ALenum param, ALfloat *pflValue)
 297 {
 298     ALCcontext *Context;
 299
 300     (void)pflValue;
 301
 302     Context = alcGetCurrentContext();
 303     SuspendContext(Context);
 304
 305     if (alIsFilter(filter))
 306     {
 307         switch(param)
 308         {
 309         default:
 310             alSetError(AL_INVALID_ENUM);
 311             break;
 312         }
 313     }
 314     else
 315         alSetError(AL_INVALID_NAME);
 316
 317     ProcessContext(Context);
 318 }
 319
 320 AL_API ALvoid AL_APIENTRY alGetFilterfv(ALuint filter, ALenum param, ALfloat *pflValues)
 321 {
 322     ALCcontext *Context;
 323
 324     (void)pflValues;
 325
 326     Context = alcGetCurrentContext();
 327     SuspendContext(Context);
 328
 329     if (alIsFilter(filter))
 330     {
 331         switch(param)
 332         {
 333         default:
 334             alSetError(AL_INVALID_ENUM);
 335             break;
 336         }
 337     }
 338     else
 339         alSetError(AL_INVALID_NAME);
 340
 341     ProcessContext(Context);
 342 }
 343
 344
 345 static void InitFilterParams(ALfilter *filter, ALenum type)
 346 {
 347     filter->type = type;
 348 }