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