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 "config.h"
  22
  23 #include <stdlib.h>
  24 #include <math.h>
  25
  26 #include "AL/al.h"
  27 #include "AL/alc.h"
  28 #include "alMain.h"
  29 #include "alAuxEffectSlot.h"
  30 #include "alThunk.h"
  31 #include "alError.h"
  32 #include "alReverb.h"
  33
  34
  35 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect);
  36
  37
  38 ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  39 {
  40     ALCcontext *Context;
  41     ALsizei i;
  42
  43     Context = alcGetCurrentContext();
  44     if(!Context)
  45     {
  46         alSetError(AL_INVALID_OPERATION);
  47         return;
  48     }
  49     SuspendContext(Context);
  50
  51     if (n > 0)
  52     {
  53         /* NOTE: We only support one slot currently */
  54         if(n == 1 && Context->AuxiliaryEffectSlotCount == 0)
  55         {
  56             // Check that enough memory has been allocted in the 'effectslots' array for n Effect Slots
  57             if (!IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
  58             {
  59                 ALeffectslot **list = &Context->AuxiliaryEffectSlot;
  60                 while(*list)
  61                     list = &(*list)->next;
  62
  63                 i = 0;
  64                 while(i < n)
  65                 {
  66                     *list = calloc(1, sizeof(ALeffectslot));
  67                     if(!(*list))
  68                     {
  69                         // We must have run out or memory
  70                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  71                         alSetError(AL_OUT_OF_MEMORY);
  72                         break;
  73                     }
  74
  75                     (*list)->Gain = 1.0;
  76                     (*list)->AuxSendAuto = AL_TRUE;
  77                     (*list)->refcount = 0;
  78
  79                     effectslots[i] = (ALuint)ALTHUNK_ADDENTRY(*list);
  80                     (*list)->effectslot = effectslots[i];
  81
  82                     Context->AuxiliaryEffectSlotCount++;
  83                     i++;
  84
  85                     list = &(*list)->next;
  86                 }
  87             }
  88         }
  89         else
  90             alSetError(AL_INVALID_OPERATION);
  91     }
  92
  93     ProcessContext(Context);
  94 }
  95
  96 ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  97 {
  98     ALCcontext *Context;
  99     ALeffectslot *ALAuxiliaryEffectSlot;
 100     ALsizei i;
 101
 102     Context = alcGetCurrentContext();
 103     if(!Context)
 104     {
 105         alSetError(AL_INVALID_OPERATION);
 106         return;
 107     }
 108     SuspendContext(Context);
 109
 110     if (n >= 0)
 111     {
 112         // Check that all effectslots are valid
 113         for (i = 0; i < n; i++)
 114         {
 115             if (!alIsAuxiliaryEffectSlot(effectslots[i]))
 116             {
 117                 alSetError(AL_INVALID_NAME);
 118                 break;
 119             }
 120             else
 121             {
 122                 ALAuxiliaryEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslots[i]);
 123                 if(ALAuxiliaryEffectSlot->refcount > 0)
 124                 {
 125                     alSetError(AL_INVALID_NAME);
 126                     break;
 127                 }
 128             }
 129         }
 130
 131         if (i == n)
 132         {
 133             // All effectslots are valid
 134             for (i = 0; i < n; i++)
 135             {
 136                 // Recheck that the effectslot is valid, because there could be duplicated names
 137                 if (alIsAuxiliaryEffectSlot(effectslots[i]))
 138                 {
 139                     ALeffectslot **list;
 140
 141                     ALAuxiliaryEffectSlot = ((ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslots[i]));
 142
 143                     // Remove Source from list of Sources
 144                     list = &Context->AuxiliaryEffectSlot;
 145                     while(*list && *list != ALAuxiliaryEffectSlot)
 146                          list = &(*list)->next;
 147
 148                     if(*list)
 149                         *list = (*list)->next;
 150                     ALTHUNK_REMOVEENTRY(ALAuxiliaryEffectSlot->effectslot);
 151
 152                     VerbDestroy(ALAuxiliaryEffectSlot->ReverbState);
 153
 154                     memset(ALAuxiliaryEffectSlot, 0, sizeof(ALeffectslot));
 155                     free(ALAuxiliaryEffectSlot);
 156
 157                     Context->AuxiliaryEffectSlotCount--;
 158                 }
 159             }
 160         }
 161     }
 162     else
 163         alSetError(AL_INVALID_VALUE);
 164
 165     ProcessContext(Context);
 166 }
 167
 168 ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 169 {
 170     ALCcontext *Context;
 171     ALeffectslot **list;
 172
 173     Context = alcGetCurrentContext();
 174     if(!Context)
 175     {
 176         alSetError(AL_INVALID_OPERATION);
 177         return AL_FALSE;
 178     }
 179     SuspendContext(Context);
 180
 181     list = &Context->AuxiliaryEffectSlot;
 182     while(*list && (*list)->effectslot != effectslot)
 183         list = &(*list)->next;
 184
 185     ProcessContext(Context);
 186
 187     return (*list ? AL_TRUE : AL_FALSE);
 188 }
 189
 190 ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 191 {
 192     ALCcontext *Context;
 193
 194     Context = alcGetCurrentContext();
 195     if(!Context)
 196     {
 197         alSetError(AL_INVALID_OPERATION);
 198         return;
 199     }
 200     SuspendContext(Context);
 201
 202     if (alIsAuxiliaryEffectSlot(effectslot))
 203     {
 204         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 205
 206         switch(param)
 207         {
 208         case AL_EFFECTSLOT_EFFECT:
 209             if(alIsEffect(iValue))
 210             {
 211                 ALeffect *effect = (ALeffect*)ALTHUNK_LOOKUPENTRY(iValue);
 212                 InitializeEffect(Context, ALEffectSlot, 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 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 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 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 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 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 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 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 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect)
 470 {
 471     if(!effect)
 472     {
 473         memset(&ALEffectSlot->effect, 0, sizeof(ALEffectSlot->effect));
 474         VerbDestroy(ALEffectSlot->ReverbState);
 475         ALEffectSlot->ReverbState = NULL;
 476         return;
 477     }
 478     if(effect->type == AL_EFFECT_REVERB)
 479     {
 480         if(!ALEffectSlot->ReverbState)
 481             ALEffectSlot->ReverbState = VerbCreate(Context);
 482         VerbUpdate(Context, ALEffectSlot, effect);
 483     }
 484     memcpy(&ALEffectSlot->effect, effect, sizeof(*effect));
 485 }
 486
 487
 488 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 489 {
 490 #ifdef _DEBUG
 491     if(Context->AuxiliaryEffectSlotCount > 0)
 492         AL_PRINT("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", Context->AuxiliaryEffectSlotCount);
 493 #endif
 494
 495     while(Context->AuxiliaryEffectSlot)
 496     {
 497         ALeffectslot *temp = Context->AuxiliaryEffectSlot;
 498         Context->AuxiliaryEffectSlot = Context->AuxiliaryEffectSlot->next;
 499
 500         // Release effectslot structure
 501         VerbDestroy(temp->ReverbState);
 502         ALTHUNK_REMOVEENTRY(temp->effectslot);
 503
 504         memset(temp, 0, sizeof(ALeffectslot));
 505         free(temp);
 506     }
 507     Context->AuxiliaryEffectSlotCount = 0;
 508 }