OpenAL32/alEffect.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 "alEffect.h"
  30
  31 static ALeffect *g_EffectList;
  32 static ALuint    g_EffectCount;
  33
  34 static void InitEffectParams(ALeffect *effect, ALenum type);
  35
  36
  37 AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
  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*)effects, n * sizeof(ALuint)))
  49         {
  50             ALeffect **list = &g_EffectList;
  51             while(*list)
  52                 list = &(*list)->next;
  53
  54             i = 0;
  55             while(i < n)
  56             {
  57                 *list = calloc(1, sizeof(ALeffect));
  58                 if(!(*list))
  59                 {
  60                     // We must have run out or memory
  61                     alDeleteEffects(i, effects);
  62                     alSetError(AL_OUT_OF_MEMORY);
  63                     break;
  64                 }
  65
  66                 effects[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  67                 (*list)->effect = effects[i];
  68
  69                 InitEffectParams(*list, AL_EFFECT_NULL);
  70                 g_EffectCount++;
  71                 i++;
  72             }
  73         }
  74     }
  75
  76     ProcessContext(Context);
  77 }
  78
  79 AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
  80 {
  81     ALCcontext *Context;
  82     ALeffect *ALEffect;
  83     ALsizei i;
  84
  85     Context = alcGetCurrentContext();
  86     SuspendContext(Context);
  87
  88     if (n >= 0)
  89     {
  90         // Check that all effects are valid
  91         for (i = 0; i < n; i++)
  92         {
  93             if (!alIsEffect(effects[i]))
  94             {
  95                 alSetError(AL_INVALID_NAME);
  96                 break;
  97             }
  98         }
  99
 100         if (i == n)
 101         {
 102             // All effects are valid
 103             for (i = 0; i < n; i++)
 104             {
 105                 // Recheck that the effect is valid, because there could be duplicated names
 106                 if (effects[i] && alIsEffect(effects[i]))
 107                 {
 108                     ALeffect **list;
 109
 110                     ALEffect = ((ALeffect*)ALTHUNK_LOOKUPENTRY(effects[i]));
 111
 112                     // Remove Source from list of Sources
 113                     list = &g_EffectList;
 114                     while(*list && *list != ALEffect)
 115                          list = &(*list)->next;
 116
 117                     if(*list)
 118                         *list = (*list)->next;
 119                     ALTHUNK_REMOVEENTRY(ALEffect->effect);
 120
 121                     memset(ALEffect, 0, sizeof(ALeffect));
 122                     free(ALEffect);
 123
 124                     g_EffectCount--;
 125                 }
 126             }
 127         }
 128     }
 129     else
 130         alSetError(AL_INVALID_VALUE);
 131
 132     ProcessContext(Context);
 133 }
 134
 135 AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 136 {
 137     ALCcontext *Context;
 138     ALeffect **list;
 139
 140     Context = alcGetCurrentContext();
 141     SuspendContext(Context);
 142
 143     list = &g_EffectList;
 144     while(*list && (*list)->effect != effect)
 145         list = &(*list)->next;
 146
 147     ProcessContext(Context);
 148
 149     return ((*list || !effect) ? AL_TRUE : AL_FALSE);
 150 }
 151
 152 AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 153 {
 154     ALCcontext *Context;
 155
 156     (void)iValue;
 157
 158     Context = alcGetCurrentContext();
 159     SuspendContext(Context);
 160
 161     if (alIsEffect(effect))
 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 alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 177 {
 178     ALCcontext *Context;
 179
 180     (void)piValues;
 181
 182     Context = alcGetCurrentContext();
 183     SuspendContext(Context);
 184
 185     if (alIsEffect(effect))
 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 alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 201 {
 202     ALCcontext *Context;
 203
 204     (void)flValue;
 205
 206     Context = alcGetCurrentContext();
 207     SuspendContext(Context);
 208
 209     if (alIsEffect(effect))
 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 alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 225 {
 226     ALCcontext *Context;
 227
 228     (void)pflValues;
 229
 230     Context = alcGetCurrentContext();
 231     SuspendContext(Context);
 232
 233     if (alIsEffect(effect))
 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 alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 249 {
 250     ALCcontext *Context;
 251
 252     (void)piValue;
 253
 254     Context = alcGetCurrentContext();
 255     SuspendContext(Context);
 256
 257     if (alIsEffect(effect))
 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 alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 273 {
 274     ALCcontext *Context;
 275
 276     (void)piValues;
 277
 278     Context = alcGetCurrentContext();
 279     SuspendContext(Context);
 280
 281     if (alIsEffect(effect))
 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 alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 297 {
 298     ALCcontext *Context;
 299
 300     (void)pflValue;
 301
 302     Context = alcGetCurrentContext();
 303     SuspendContext(Context);
 304
 305     if (alIsEffect(effect))
 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 alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 321 {
 322     ALCcontext *Context;
 323
 324     (void)pflValues;
 325
 326     Context = alcGetCurrentContext();
 327     SuspendContext(Context);
 328
 329     if (alIsEffect(effect))
 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 ALvoid ReleaseALEffects(ALvoid)
 346 {
 347 #ifdef _DEBUG
 348     if(g_EffectCount > 0)
 349         AL_PRINT("exit() %d Effect(s) NOT deleted\n", g_EffectCount);
 350 #endif
 351
 352     while(g_EffectList)
 353     {
 354         ALeffect *temp = g_EffectList;
 355         g_EffectList = g_EffectList->next;
 356
 357         // Release effect structure
 358         memset(temp, 0, sizeof(ALeffect));
 359         free(temp);
 360     }
 361     g_EffectCount = 0;
 362 }
 363
 364
 365 static void InitEffectParams(ALeffect *effect, ALenum type)
 366 {
 367     effect->type = type;
 368 }