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