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
  33
  34 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect);
  35
  36
  37 ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  38 {
  39     ALCcontext *Context;
  40     ALsizei i, j;
  41
  42     Context = alcGetCurrentContext();
  43     if(!Context)
  44     {
  45         alSetError(AL_INVALID_OPERATION);
  46         return;
  47     }
  48     SuspendContext(Context);
  49
  50     if (n > 0)
  51     {
  52         if(Context->AuxiliaryEffectSlotCount+n <= Context->AuxiliaryEffectSlotMax)
  53         {
  54             // Check that enough memory has been allocted in the 'effectslots' array for n Effect Slots
  55             if (!IsBadWritePtr((void*)effectslots, n * sizeof(ALuint)))
  56             {
  57                 ALeffectslot **list = &Context->AuxiliaryEffectSlot;
  58                 while(*list)
  59                     list = &(*list)->next;
  60
  61                 i = 0;
  62                 while(i < n)
  63                 {
  64                     *list = calloc(1, sizeof(ALeffectslot));
  65                     if(!(*list))
  66                     {
  67                         // We must have run out or memory
  68                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  69                         alSetError(AL_OUT_OF_MEMORY);
  70                         break;
  71                     }
  72
  73                     (*list)->Gain = 1.0;
  74                     (*list)->AuxSendAuto = AL_TRUE;
  75                     for(j = 0;j < BUFFERSIZE;j++)
  76                         (*list)->WetBuffer[j] = 0.0f;
  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                     if(ALAuxiliaryEffectSlot->EffectState)
 153                         ALEffect_Destroy(ALAuxiliaryEffectSlot->EffectState);
 154
 155                     memset(ALAuxiliaryEffectSlot, 0, sizeof(ALeffectslot));
 156                     free(ALAuxiliaryEffectSlot);
 157
 158                     Context->AuxiliaryEffectSlotCount--;
 159                 }
 160             }
 161         }
 162     }
 163     else
 164         alSetError(AL_INVALID_VALUE);
 165
 166     ProcessContext(Context);
 167 }
 168
 169 ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 170 {
 171     ALCcontext *Context;
 172     ALeffectslot **list;
 173
 174     Context = alcGetCurrentContext();
 175     if(!Context)
 176     {
 177         alSetError(AL_INVALID_OPERATION);
 178         return AL_FALSE;
 179     }
 180     SuspendContext(Context);
 181
 182     list = &Context->AuxiliaryEffectSlot;
 183     while(*list && (*list)->effectslot != effectslot)
 184         list = &(*list)->next;
 185
 186     ProcessContext(Context);
 187
 188     return (*list ? AL_TRUE : AL_FALSE);
 189 }
 190
 191 ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 192 {
 193     ALCcontext *Context;
 194
 195     Context = alcGetCurrentContext();
 196     if(!Context)
 197     {
 198         alSetError(AL_INVALID_OPERATION);
 199         return;
 200     }
 201     SuspendContext(Context);
 202
 203     if (alIsAuxiliaryEffectSlot(effectslot))
 204     {
 205         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 206
 207         switch(param)
 208         {
 209         case AL_EFFECTSLOT_EFFECT:
 210             if(alIsEffect(iValue))
 211             {
 212                 ALeffect *effect = (ALeffect*)ALTHUNK_LOOKUPENTRY(iValue);
 213                 InitializeEffect(Context, ALEffectSlot, effect);
 214             }
 215             else
 216                 alSetError(AL_INVALID_VALUE);
 217             break;
 218
 219         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 220             if(iValue == AL_TRUE || iValue == AL_FALSE)
 221                 ALEffectSlot->AuxSendAuto = iValue;
 222             else
 223                 alSetError(AL_INVALID_VALUE);
 224             break;
 225
 226         default:
 227             alSetError(AL_INVALID_ENUM);
 228             break;
 229         }
 230     }
 231     else
 232         alSetError(AL_INVALID_NAME);
 233
 234     ProcessContext(Context);
 235 }
 236
 237 ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 238 {
 239     ALCcontext *Context;
 240
 241     Context = alcGetCurrentContext();
 242     if(!Context)
 243     {
 244         alSetError(AL_INVALID_OPERATION);
 245         return;
 246     }
 247     SuspendContext(Context);
 248
 249     if (alIsAuxiliaryEffectSlot(effectslot))
 250     {
 251         switch(param)
 252         {
 253         case AL_EFFECTSLOT_EFFECT:
 254         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 255             alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
 256             break;
 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 ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 270 {
 271     ALCcontext *Context;
 272
 273     Context = alcGetCurrentContext();
 274     if(!Context)
 275     {
 276         alSetError(AL_INVALID_OPERATION);
 277         return;
 278     }
 279     SuspendContext(Context);
 280
 281     if (alIsAuxiliaryEffectSlot(effectslot))
 282     {
 283         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 284
 285         switch(param)
 286         {
 287         case AL_EFFECTSLOT_GAIN:
 288             if(flValue >= 0.0f && flValue <= 1.0f)
 289                 ALEffectSlot->Gain = flValue;
 290             else
 291                 alSetError(AL_INVALID_VALUE);
 292             break;
 293
 294         default:
 295             alSetError(AL_INVALID_ENUM);
 296             break;
 297         }
 298     }
 299     else
 300         alSetError(AL_INVALID_NAME);
 301
 302     ProcessContext(Context);
 303 }
 304
 305 ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 306 {
 307     ALCcontext *Context;
 308
 309     Context = alcGetCurrentContext();
 310     if(!Context)
 311     {
 312         alSetError(AL_INVALID_OPERATION);
 313         return;
 314     }
 315     SuspendContext(Context);
 316
 317     if (alIsAuxiliaryEffectSlot(effectslot))
 318     {
 319         switch(param)
 320         {
 321         case AL_EFFECTSLOT_GAIN:
 322             alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
 323             break;
 324
 325         default:
 326             alSetError(AL_INVALID_ENUM);
 327             break;
 328         }
 329     }
 330     else
 331         alSetError(AL_INVALID_NAME);
 332
 333     ProcessContext(Context);
 334 }
 335
 336 ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 337 {
 338     ALCcontext *Context;
 339
 340     Context = alcGetCurrentContext();
 341     if(!Context)
 342     {
 343         alSetError(AL_INVALID_OPERATION);
 344         return;
 345     }
 346     SuspendContext(Context);
 347
 348     if (alIsAuxiliaryEffectSlot(effectslot))
 349     {
 350         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 351
 352         switch(param)
 353         {
 354         case AL_EFFECTSLOT_EFFECT:
 355             *piValue = ALEffectSlot->effect.effect;
 356             break;
 357
 358         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 359             *piValue = ALEffectSlot->AuxSendAuto;
 360             break;
 361
 362         default:
 363             alSetError(AL_INVALID_ENUM);
 364             break;
 365         }
 366     }
 367     else
 368         alSetError(AL_INVALID_NAME);
 369
 370     ProcessContext(Context);
 371 }
 372
 373 ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 374 {
 375     ALCcontext *Context;
 376
 377     Context = alcGetCurrentContext();
 378     if(!Context)
 379     {
 380         alSetError(AL_INVALID_OPERATION);
 381         return;
 382     }
 383     SuspendContext(Context);
 384
 385     if (alIsAuxiliaryEffectSlot(effectslot))
 386     {
 387         switch(param)
 388         {
 389         case AL_EFFECTSLOT_EFFECT:
 390         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 391             alGetAuxiliaryEffectSloti(effectslot, param, piValues);
 392             break;
 393
 394         default:
 395             alSetError(AL_INVALID_ENUM);
 396             break;
 397         }
 398     }
 399     else
 400         alSetError(AL_INVALID_NAME);
 401
 402     ProcessContext(Context);
 403 }
 404
 405 ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 406 {
 407     ALCcontext *Context;
 408
 409     Context = alcGetCurrentContext();
 410     if(!Context)
 411     {
 412         alSetError(AL_INVALID_OPERATION);
 413         return;
 414     }
 415     SuspendContext(Context);
 416
 417     if (alIsAuxiliaryEffectSlot(effectslot))
 418     {
 419         ALeffectslot *ALEffectSlot = (ALeffectslot*)ALTHUNK_LOOKUPENTRY(effectslot);
 420
 421         switch(param)
 422         {
 423         case AL_EFFECTSLOT_GAIN:
 424             *pflValue = ALEffectSlot->Gain;
 425             break;
 426
 427         default:
 428             alSetError(AL_INVALID_ENUM);
 429             break;
 430         }
 431     }
 432     else
 433         alSetError(AL_INVALID_NAME);
 434
 435     ProcessContext(Context);
 436 }
 437
 438 ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 439 {
 440     ALCcontext *Context;
 441
 442     Context = alcGetCurrentContext();
 443     if(!Context)
 444     {
 445         alSetError(AL_INVALID_OPERATION);
 446         return;
 447     }
 448     SuspendContext(Context);
 449
 450     if (alIsAuxiliaryEffectSlot(effectslot))
 451     {
 452         switch(param)
 453         {
 454         case AL_EFFECTSLOT_GAIN:
 455             alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
 456             break;
 457
 458         default:
 459             alSetError(AL_INVALID_ENUM);
 460             break;
 461         }
 462     }
 463     else
 464         alSetError(AL_INVALID_NAME);
 465
 466     ProcessContext(Context);
 467 }
 468
 469
 470 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *ALEffectSlot, ALeffect *effect)
 471 {
 472     if((!effect) || (effect->type != ALEffectSlot->effect.type))
 473     {
 474         ALeffectState *NewState = NULL;
 475         if(effect)
 476         {
 477             if(effect->type == AL_EFFECT_EAXREVERB)
 478                 NewState = EAXVerbCreate(Context);
 479             else if(effect->type == AL_EFFECT_REVERB)
 480                 NewState = VerbCreate(Context);
 481             else if(effect->type == AL_EFFECT_ECHO)
 482                 NewState = EchoCreate(Context);
 483             /* No new state? An error occured.. */
 484             if(!NewState)
 485                 return;
 486         }
 487         if(ALEffectSlot->EffectState)
 488             ALEffect_Destroy(ALEffectSlot->EffectState);
 489         ALEffectSlot->EffectState = NewState;
 490     }
 491     if(!effect)
 492     {
 493         memset(&ALEffectSlot->effect, 0, sizeof(ALEffectSlot->effect));
 494         return;
 495     }
 496     memcpy(&ALEffectSlot->effect, effect, sizeof(*effect));
 497     ALEffect_Update(ALEffectSlot->EffectState, Context, effect);
 498 }
 499
 500
 501 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 502 {
 503 #ifdef _DEBUG
 504     if(Context->AuxiliaryEffectSlotCount > 0)
 505         AL_PRINT("alcDestroyContext(): deleting %d AuxiliaryEffectSlot(s)\n", Context->AuxiliaryEffectSlotCount);
 506 #endif
 507
 508     while(Context->AuxiliaryEffectSlot)
 509     {
 510         ALeffectslot *temp = Context->AuxiliaryEffectSlot;
 511         Context->AuxiliaryEffectSlot = Context->AuxiliaryEffectSlot->next;
 512
 513         // Release effectslot structure
 514         if(temp->EffectState)
 515             ALEffect_Destroy(temp->EffectState);
 516         ALTHUNK_REMOVEENTRY(temp->effectslot);
 517
 518         memset(temp, 0, sizeof(ALeffectslot));
 519         free(temp);
 520     }
 521     Context->AuxiliaryEffectSlotCount = 0;
 522 }