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