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