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 "alSource.h"
  33
  34
  35 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect);
  36
  37 #define LookupEffectSlot(m, k) ((ALeffectslot*)LookupUIntMapKey(&(m), (k)))
  38 #define LookupEffect(m, k) ((ALeffect*)LookupUIntMapKey(&(m), (k)))
  39
  40 AL_API ALvoid AL_APIENTRY alGenAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
  41 {
  42     ALCcontext *Context;
  43     ALsizei i=0, j;
  44
  45     Context = GetContextSuspended();
  46     if(!Context) return;
  47
  48     if(n > 0)
  49     {
  50         ALCdevice *Device = Context->Device;
  51
  52         if(Context->EffectSlotMap.size+n <= (ALsizei)Device->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                 ALenum err;
  58
  59                 while(i < n)
  60                 {
  61                     ALeffectslot *slot = calloc(1, sizeof(ALeffectslot));
  62                     if(!slot || !(slot->EffectState=NoneCreate()))
  63                     {
  64                         free(slot);
  65                         // We must have run out or memory
  66                         alSetError(Context, AL_OUT_OF_MEMORY);
  67                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  68                         break;
  69                     }
  70
  71                     slot->effectslot = (ALuint)ALTHUNK_ADDENTRY(slot);
  72                     err = InsertUIntMapEntry(&Context->EffectSlotMap,
  73                                              slot->effectslot, slot);
  74                     if(err != AL_NO_ERROR)
  75                     {
  76                         ALTHUNK_REMOVEENTRY(slot->effectslot);
  77                         ALEffect_Destroy(slot->EffectState);
  78                         free(slot);
  79
  80                         alSetError(Context, err);
  81                         alDeleteAuxiliaryEffectSlots(i, effectslots);
  82                         break;
  83                     }
  84
  85                     effectslots[i++] = slot->effectslot;
  86
  87                     slot->Gain = 1.0;
  88                     slot->AuxSendAuto = AL_TRUE;
  89                     for(j = 0;j < BUFFERSIZE;j++)
  90                         slot->WetBuffer[j] = 0.0f;
  91                     slot->refcount = 0;
  92                 }
  93             }
  94         }
  95         else
  96             alSetError(Context, AL_INVALID_OPERATION);
  97     }
  98
  99     ProcessContext(Context);
 100 }
 101
 102 AL_API ALvoid AL_APIENTRY alDeleteAuxiliaryEffectSlots(ALsizei n, ALuint *effectslots)
 103 {
 104     ALCcontext *Context;
 105     ALeffectslot *EffectSlot;
 106     ALsizei i;
 107
 108     Context = GetContextSuspended();
 109     if(!Context) return;
 110
 111     if (n >= 0)
 112     {
 113         // Check that all effectslots are valid
 114         for (i = 0; i < n; i++)
 115         {
 116             if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) == NULL)
 117             {
 118                 alSetError(Context, AL_INVALID_NAME);
 119                 break;
 120             }
 121             else
 122             {
 123                 if(EffectSlot->refcount > 0)
 124                 {
 125                     alSetError(Context, 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((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslots[i])) != NULL)
 138                 {
 139                     ALEffect_Destroy(EffectSlot->EffectState);
 140
 141                     RemoveUIntMapKey(&Context->EffectSlotMap, EffectSlot->effectslot);
 142                     ALTHUNK_REMOVEENTRY(EffectSlot->effectslot);
 143
 144                     memset(EffectSlot, 0, sizeof(ALeffectslot));
 145                     free(EffectSlot);
 146                 }
 147             }
 148         }
 149     }
 150     else
 151         alSetError(Context, AL_INVALID_VALUE);
 152
 153     ProcessContext(Context);
 154 }
 155
 156 AL_API ALboolean AL_APIENTRY alIsAuxiliaryEffectSlot(ALuint effectslot)
 157 {
 158     ALCcontext *Context;
 159     ALboolean  result;
 160
 161     Context = GetContextSuspended();
 162     if(!Context) return AL_FALSE;
 163
 164     result = (LookupEffectSlot(Context->EffectSlotMap, effectslot) ?
 165               AL_TRUE : AL_FALSE);
 166
 167     ProcessContext(Context);
 168
 169     return result;
 170 }
 171
 172 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint iValue)
 173 {
 174     ALCcontext *Context;
 175     ALboolean updateSources = AL_FALSE;
 176     ALeffectslot *EffectSlot;
 177
 178     Context = GetContextSuspended();
 179     if(!Context) return;
 180
 181     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 182     {
 183         switch(param)
 184         {
 185         case AL_EFFECTSLOT_EFFECT: {
 186             ALeffect *effect = NULL;
 187
 188             if(iValue == 0 ||
 189                (effect=LookupEffect(Context->Device->EffectMap, iValue)) != NULL)
 190             {
 191                 InitializeEffect(Context, EffectSlot, effect);
 192                 updateSources = AL_TRUE;
 193             }
 194             else
 195                 alSetError(Context, AL_INVALID_VALUE);
 196         }   break;
 197
 198         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 199             if(iValue == AL_TRUE || iValue == AL_FALSE)
 200             {
 201                 EffectSlot->AuxSendAuto = iValue;
 202                 updateSources = AL_TRUE;
 203             }
 204             else
 205                 alSetError(Context, AL_INVALID_VALUE);
 206             break;
 207
 208         default:
 209             alSetError(Context, AL_INVALID_ENUM);
 210             break;
 211         }
 212     }
 213     else
 214         alSetError(Context, AL_INVALID_NAME);
 215
 216     // Force updating the sources that use this slot, since it affects the
 217     // sending parameters
 218     if(updateSources)
 219     {
 220         ALsizei pos;
 221         for(pos = 0;pos < Context->SourceMap.size;pos++)
 222         {
 223             ALsource *source = Context->SourceMap.array[pos].value;
 224             ALuint i;
 225             for(i = 0;i < MAX_SENDS;i++)
 226             {
 227                 if(!source->Send[i].Slot ||
 228                    source->Send[i].Slot->effectslot != effectslot)
 229                     continue;
 230                 source->NeedsUpdate = AL_TRUE;
 231                 break;
 232             }
 233         }
 234     }
 235
 236     ProcessContext(Context);
 237 }
 238
 239 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 240 {
 241     ALCcontext *Context;
 242
 243     Context = GetContextSuspended();
 244     if(!Context) return;
 245
 246     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 247     {
 248         switch(param)
 249         {
 250         case AL_EFFECTSLOT_EFFECT:
 251         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 252             alAuxiliaryEffectSloti(effectslot, param, piValues[0]);
 253             break;
 254
 255         default:
 256             alSetError(Context, AL_INVALID_ENUM);
 257             break;
 258         }
 259     }
 260     else
 261         alSetError(Context, AL_INVALID_NAME);
 262
 263     ProcessContext(Context);
 264 }
 265
 266 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat flValue)
 267 {
 268     ALCcontext *Context;
 269     ALeffectslot *EffectSlot;
 270
 271     Context = GetContextSuspended();
 272     if(!Context) return;
 273
 274     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 275     {
 276         switch(param)
 277         {
 278         case AL_EFFECTSLOT_GAIN:
 279             if(flValue >= 0.0f && flValue <= 1.0f)
 280                 EffectSlot->Gain = flValue;
 281             else
 282                 alSetError(Context, AL_INVALID_VALUE);
 283             break;
 284
 285         default:
 286             alSetError(Context, AL_INVALID_ENUM);
 287             break;
 288         }
 289     }
 290     else
 291         alSetError(Context, AL_INVALID_NAME);
 292
 293     ProcessContext(Context);
 294 }
 295
 296 AL_API ALvoid AL_APIENTRY alAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 297 {
 298     ALCcontext *Context;
 299
 300     Context = GetContextSuspended();
 301     if(!Context) return;
 302
 303     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 304     {
 305         switch(param)
 306         {
 307         case AL_EFFECTSLOT_GAIN:
 308             alAuxiliaryEffectSlotf(effectslot, param, pflValues[0]);
 309             break;
 310
 311         default:
 312             alSetError(Context, AL_INVALID_ENUM);
 313             break;
 314         }
 315     }
 316     else
 317         alSetError(Context, AL_INVALID_NAME);
 318
 319     ProcessContext(Context);
 320 }
 321
 322 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSloti(ALuint effectslot, ALenum param, ALint *piValue)
 323 {
 324     ALCcontext *Context;
 325     ALeffectslot *EffectSlot;
 326
 327     Context = GetContextSuspended();
 328     if(!Context) return;
 329
 330     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 331     {
 332         switch(param)
 333         {
 334         case AL_EFFECTSLOT_EFFECT:
 335             *piValue = EffectSlot->effect.effect;
 336             break;
 337
 338         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 339             *piValue = EffectSlot->AuxSendAuto;
 340             break;
 341
 342         default:
 343             alSetError(Context, AL_INVALID_ENUM);
 344             break;
 345         }
 346     }
 347     else
 348         alSetError(Context, AL_INVALID_NAME);
 349
 350     ProcessContext(Context);
 351 }
 352
 353 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotiv(ALuint effectslot, ALenum param, ALint *piValues)
 354 {
 355     ALCcontext *Context;
 356
 357     Context = GetContextSuspended();
 358     if(!Context) return;
 359
 360     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 361     {
 362         switch(param)
 363         {
 364         case AL_EFFECTSLOT_EFFECT:
 365         case AL_EFFECTSLOT_AUXILIARY_SEND_AUTO:
 366             alGetAuxiliaryEffectSloti(effectslot, param, piValues);
 367             break;
 368
 369         default:
 370             alSetError(Context, AL_INVALID_ENUM);
 371             break;
 372         }
 373     }
 374     else
 375         alSetError(Context, AL_INVALID_NAME);
 376
 377     ProcessContext(Context);
 378 }
 379
 380 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotf(ALuint effectslot, ALenum param, ALfloat *pflValue)
 381 {
 382     ALCcontext *Context;
 383     ALeffectslot *EffectSlot;
 384
 385     Context = GetContextSuspended();
 386     if(!Context) return;
 387
 388     if((EffectSlot=LookupEffectSlot(Context->EffectSlotMap, effectslot)) != NULL)
 389     {
 390         switch(param)
 391         {
 392         case AL_EFFECTSLOT_GAIN:
 393             *pflValue = EffectSlot->Gain;
 394             break;
 395
 396         default:
 397             alSetError(Context, AL_INVALID_ENUM);
 398             break;
 399         }
 400     }
 401     else
 402         alSetError(Context, AL_INVALID_NAME);
 403
 404     ProcessContext(Context);
 405 }
 406
 407 AL_API ALvoid AL_APIENTRY alGetAuxiliaryEffectSlotfv(ALuint effectslot, ALenum param, ALfloat *pflValues)
 408 {
 409     ALCcontext *Context;
 410
 411     Context = GetContextSuspended();
 412     if(!Context) return;
 413
 414     if(LookupEffectSlot(Context->EffectSlotMap, effectslot) != NULL)
 415     {
 416         switch(param)
 417         {
 418         case AL_EFFECTSLOT_GAIN:
 419             alGetAuxiliaryEffectSlotf(effectslot, param, pflValues);
 420             break;
 421
 422         default:
 423             alSetError(Context, AL_INVALID_ENUM);
 424             break;
 425         }
 426     }
 427     else
 428         alSetError(Context, AL_INVALID_NAME);
 429
 430     ProcessContext(Context);
 431 }
 432
 433
 434 static ALvoid NoneDestroy(ALeffectState *State)
 435 { free(State); }
 436 static ALboolean NoneDeviceUpdate(ALeffectState *State, ALCdevice *Device)
 437 {
 438     return AL_TRUE;
 439     (void)State;
 440     (void)Device;
 441 }
 442 static ALvoid NoneUpdate(ALeffectState *State, ALCcontext *Context, const ALeffect *Effect)
 443 {
 444     (void)State;
 445     (void)Context;
 446     (void)Effect;
 447 }
 448 static ALvoid NoneProcess(ALeffectState *State, const ALeffectslot *Slot, ALuint SamplesToDo, const ALfloat *SamplesIn, ALfloat (*SamplesOut)[OUTPUTCHANNELS])
 449 {
 450     (void)State;
 451     (void)Slot;
 452     (void)SamplesToDo;
 453     (void)SamplesIn;
 454     (void)SamplesOut;
 455 }
 456 ALeffectState *NoneCreate(void)
 457 {
 458     ALeffectState *state;
 459
 460     state = calloc(1, sizeof(*state));
 461     if(!state)
 462         return NULL;
 463
 464     state->Destroy = NoneDestroy;
 465     state->DeviceUpdate = NoneDeviceUpdate;
 466     state->Update = NoneUpdate;
 467     state->Process = NoneProcess;
 468
 469     return state;
 470 }
 471
 472 static ALvoid InitializeEffect(ALCcontext *Context, ALeffectslot *EffectSlot, ALeffect *effect)
 473 {
 474     if(EffectSlot->effect.type != (effect?effect->type:AL_EFFECT_NULL))
 475     {
 476         ALeffectState *NewState = NULL;
 477         if(!effect || effect->type == AL_EFFECT_NULL)
 478             NewState = NoneCreate();
 479         else if(effect->type == AL_EFFECT_EAXREVERB)
 480             NewState = EAXVerbCreate();
 481         else if(effect->type == AL_EFFECT_REVERB)
 482             NewState = VerbCreate();
 483         else if(effect->type == AL_EFFECT_ECHO)
 484             NewState = EchoCreate();
 485         else if(effect->type == AL_EFFECT_RING_MODULATOR)
 486             NewState = ModulatorCreate();
 487         /* No new state? An error occured.. */
 488         if(NewState == NULL ||
 489            ALEffect_DeviceUpdate(NewState, Context->Device) == AL_FALSE)
 490         {
 491             if(NewState)
 492                 ALEffect_Destroy(NewState);
 493             alSetError(Context, AL_OUT_OF_MEMORY);
 494             return;
 495         }
 496         if(EffectSlot->EffectState)
 497             ALEffect_Destroy(EffectSlot->EffectState);
 498         EffectSlot->EffectState = NewState;
 499     }
 500     if(!effect)
 501         memset(&EffectSlot->effect, 0, sizeof(EffectSlot->effect));
 502     else
 503         memcpy(&EffectSlot->effect, effect, sizeof(*effect));
 504     ALEffect_Update(EffectSlot->EffectState, Context, effect);
 505 }
 506
 507
 508 ALvoid ReleaseALAuxiliaryEffectSlots(ALCcontext *Context)
 509 {
 510     ALsizei pos;
 511     for(pos = 0;pos < Context->EffectSlotMap.size;pos++)
 512     {
 513         ALeffectslot *temp = Context->EffectSlotMap.array[pos].value;
 514         Context->EffectSlotMap.array[pos].value = NULL;
 515
 516         // Release effectslot structure
 517         ALEffect_Destroy(temp->EffectState);
 518
 519         ALTHUNK_REMOVEENTRY(temp->effectslot);
 520         memset(temp, 0, sizeof(ALeffectslot));
 521         free(temp);
 522     }
 523 }