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