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