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 #include "alThunk.h"
  31 #include "alError.h"
  32
  33 static ALeffect *g_EffectList;
  34 static ALuint    g_EffectCount;
  35
  36 static void InitEffectParams(ALeffect *effect, ALenum type);
  37
  38
  39 AL_API ALvoid AL_APIENTRY alGenEffects(ALsizei n, ALuint *effects)
  40 {
  41     ALCcontext *Context;
  42     ALsizei i;
  43
  44     Context = alcGetCurrentContext();
  45     SuspendContext(Context);
  46
  47     if (n > 0)
  48     {
  49         // Check that enough memory has been allocted in the 'effects' array for n Effects
  50         if (!IsBadWritePtr((void*)effects, n * sizeof(ALuint)))
  51         {
  52             ALeffect **list = &g_EffectList;
  53             while(*list)
  54                 list = &(*list)->next;
  55
  56             i = 0;
  57             while(i < n)
  58             {
  59                 *list = calloc(1, sizeof(ALeffect));
  60                 if(!(*list))
  61                 {
  62                     // We must have run out or memory
  63                     alDeleteEffects(i, effects);
  64                     alSetError(AL_OUT_OF_MEMORY);
  65                     break;
  66                 }
  67
  68                 effects[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  69                 (*list)->effect = effects[i];
  70
  71                 InitEffectParams(*list, AL_EFFECT_NULL);
  72                 g_EffectCount++;
  73                 i++;
  74             }
  75         }
  76     }
  77
  78     ProcessContext(Context);
  79 }
  80
  81 AL_API ALvoid AL_APIENTRY alDeleteEffects(ALsizei n, ALuint *effects)
  82 {
  83     ALCcontext *Context;
  84     ALeffect *ALEffect;
  85     ALsizei i;
  86
  87     Context = alcGetCurrentContext();
  88     SuspendContext(Context);
  89
  90     if (n >= 0)
  91     {
  92         // Check that all effects are valid
  93         for (i = 0; i < n; i++)
  94         {
  95             if (!alIsEffect(effects[i]))
  96             {
  97                 alSetError(AL_INVALID_NAME);
  98                 break;
  99             }
 100         }
 101
 102         if (i == n)
 103         {
 104             // All effects are valid
 105             for (i = 0; i < n; i++)
 106             {
 107                 // Recheck that the effect is valid, because there could be duplicated names
 108                 if (effects[i] && alIsEffect(effects[i]))
 109                 {
 110                     ALeffect **list;
 111
 112                     ALEffect = ((ALeffect*)ALTHUNK_LOOKUPENTRY(effects[i]));
 113
 114                     // Remove Source from list of Sources
 115                     list = &g_EffectList;
 116                     while(*list && *list != ALEffect)
 117                          list = &(*list)->next;
 118
 119                     if(*list)
 120                         *list = (*list)->next;
 121                     ALTHUNK_REMOVEENTRY(ALEffect->effect);
 122
 123                     memset(ALEffect, 0, sizeof(ALeffect));
 124                     free(ALEffect);
 125
 126                     g_EffectCount--;
 127                 }
 128             }
 129         }
 130     }
 131     else
 132         alSetError(AL_INVALID_VALUE);
 133
 134     ProcessContext(Context);
 135 }
 136
 137 AL_API ALboolean AL_APIENTRY alIsEffect(ALuint effect)
 138 {
 139     ALCcontext *Context;
 140     ALeffect **list;
 141
 142     Context = alcGetCurrentContext();
 143     SuspendContext(Context);
 144
 145     list = &g_EffectList;
 146     while(*list && (*list)->effect != effect)
 147         list = &(*list)->next;
 148
 149     ProcessContext(Context);
 150
 151     return ((*list || !effect) ? AL_TRUE : AL_FALSE);
 152 }
 153
 154 AL_API ALvoid AL_APIENTRY alEffecti(ALuint effect, ALenum param, ALint iValue)
 155 {
 156     ALCcontext *Context;
 157
 158     Context = alcGetCurrentContext();
 159     SuspendContext(Context);
 160
 161     if (effect && alIsEffect(effect))
 162     {
 163         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 164
 165         switch(param)
 166         {
 167         case AL_EFFECT_TYPE:
 168             if(iValue == AL_EFFECT_NULL)
 169                 InitEffectParams(ALEffect, 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 AL_API ALvoid AL_APIENTRY alEffectiv(ALuint effect, ALenum param, ALint *piValues)
 186 {
 187     ALCcontext *Context;
 188
 189     Context = alcGetCurrentContext();
 190     SuspendContext(Context);
 191
 192     if (effect && alIsEffect(effect))
 193     {
 194         switch(param)
 195         {
 196         case AL_EFFECT_TYPE:
 197             alEffecti(effect, param, piValues[0]);
 198             break;
 199
 200         default:
 201             alSetError(AL_INVALID_ENUM);
 202             break;
 203         }
 204     }
 205     else
 206         alSetError(AL_INVALID_NAME);
 207
 208     ProcessContext(Context);
 209 }
 210
 211 AL_API ALvoid AL_APIENTRY alEffectf(ALuint effect, ALenum param, ALfloat flValue)
 212 {
 213     ALCcontext *Context;
 214
 215     (void)flValue;
 216
 217     Context = alcGetCurrentContext();
 218     SuspendContext(Context);
 219
 220     if (effect && alIsEffect(effect))
 221     {
 222         switch(param)
 223         {
 224         default:
 225             alSetError(AL_INVALID_ENUM);
 226             break;
 227         }
 228     }
 229     else
 230         alSetError(AL_INVALID_NAME);
 231
 232     ProcessContext(Context);
 233 }
 234
 235 AL_API ALvoid AL_APIENTRY alEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 236 {
 237     ALCcontext *Context;
 238
 239     (void)pflValues;
 240
 241     Context = alcGetCurrentContext();
 242     SuspendContext(Context);
 243
 244     if (effect && alIsEffect(effect))
 245     {
 246         switch(param)
 247         {
 248         default:
 249             alSetError(AL_INVALID_ENUM);
 250             break;
 251         }
 252     }
 253     else
 254         alSetError(AL_INVALID_NAME);
 255
 256     ProcessContext(Context);
 257 }
 258
 259 AL_API ALvoid AL_APIENTRY alGetEffecti(ALuint effect, ALenum param, ALint *piValue)
 260 {
 261     ALCcontext *Context;
 262
 263     Context = alcGetCurrentContext();
 264     SuspendContext(Context);
 265
 266     if (effect && alIsEffect(effect))
 267     {
 268         ALeffect *ALEffect = (ALeffect*)ALTHUNK_LOOKUPENTRY(effect);
 269
 270         switch(param)
 271         {
 272         case AL_EFFECT_TYPE:
 273             *piValue = ALEffect->type;
 274             break;
 275
 276         default:
 277             alSetError(AL_INVALID_ENUM);
 278             break;
 279         }
 280     }
 281     else
 282         alSetError(AL_INVALID_NAME);
 283
 284     ProcessContext(Context);
 285 }
 286
 287 AL_API ALvoid AL_APIENTRY alGetEffectiv(ALuint effect, ALenum param, ALint *piValues)
 288 {
 289     ALCcontext *Context;
 290
 291     Context = alcGetCurrentContext();
 292     SuspendContext(Context);
 293
 294     if (effect && alIsEffect(effect))
 295     {
 296         switch(param)
 297         {
 298         case AL_EFFECT_TYPE:
 299             alGetEffecti(effect, param, piValues);
 300             break;
 301
 302         default:
 303             alSetError(AL_INVALID_ENUM);
 304             break;
 305         }
 306     }
 307     else
 308         alSetError(AL_INVALID_NAME);
 309
 310     ProcessContext(Context);
 311 }
 312
 313 AL_API ALvoid AL_APIENTRY alGetEffectf(ALuint effect, ALenum param, ALfloat *pflValue)
 314 {
 315     ALCcontext *Context;
 316
 317     (void)pflValue;
 318
 319     Context = alcGetCurrentContext();
 320     SuspendContext(Context);
 321
 322     if (effect && alIsEffect(effect))
 323     {
 324         switch(param)
 325         {
 326         default:
 327             alSetError(AL_INVALID_ENUM);
 328             break;
 329         }
 330     }
 331     else
 332         alSetError(AL_INVALID_NAME);
 333
 334     ProcessContext(Context);
 335 }
 336
 337 AL_API ALvoid AL_APIENTRY alGetEffectfv(ALuint effect, ALenum param, ALfloat *pflValues)
 338 {
 339     ALCcontext *Context;
 340
 341     (void)pflValues;
 342
 343     Context = alcGetCurrentContext();
 344     SuspendContext(Context);
 345
 346     if (effect && alIsEffect(effect))
 347     {
 348         switch(param)
 349         {
 350         default:
 351             alSetError(AL_INVALID_ENUM);
 352             break;
 353         }
 354     }
 355     else
 356         alSetError(AL_INVALID_NAME);
 357
 358     ProcessContext(Context);
 359 }
 360
 361
 362 ALvoid ReleaseALEffects(ALvoid)
 363 {
 364 #ifdef _DEBUG
 365     if(g_EffectCount > 0)
 366         AL_PRINT("exit() %d Effect(s) NOT deleted\n", g_EffectCount);
 367 #endif
 368
 369     while(g_EffectList)
 370     {
 371         ALeffect *temp = g_EffectList;
 372         g_EffectList = g_EffectList->next;
 373
 374         // Release effect structure
 375         memset(temp, 0, sizeof(ALeffect));
 376         free(temp);
 377     }
 378     g_EffectCount = 0;
 379 }
 380
 381
 382 static void InitEffectParams(ALeffect *effect, ALenum type)
 383 {
 384     effect->type = type;
 385 }